arch/linux/ukali.c

   1 /*
   2  *
   3  * Kali support functions
   4  *
   5  */
   6
   7 #ifdef HAVE_CONFIG_H
   8 #include <conf.h>
   9 #endif
  10
  11 #include <sys/types.h>
  12 #include <sys/socket.h>
  13 #include <string.h>
  14 #include <netinet/in.h>
  15 #include <arpa/inet.h>
  16 #include <netdb.h>
  17 #include <stdlib.h>
  18 #include <sys/time.h>
  19 #include <errno.h>
  20 #include <unistd.h>
  21 #include <fcntl.h>
  22 #include "ukali.h"
  23 //added 05/17/99 Matt Mueller - needed to redefine FD_* so that no asm is used
  24 #include "checker.h"
  25 //end addition -MM
  26 int g_sockfd = -1;
  27 struct sockaddr_in kalinix_addr;
  28 char g_mynodenum[6];
  29
  30 int knix_newSock(void) {
  31
  32         int tempsock;
  33         struct sockaddr_in taddr;
  34
  35         taddr.sin_family = AF_INET;
  36         taddr.sin_addr.s_addr = inet_addr("127.0.0.1");
  37         taddr.sin_port = 0;
  38
  39         if ((tempsock = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
  40                 return -1;
  41
  42         fcntl(tempsock, F_SETFL, fcntl(tempsock, F_GETFL) | O_NONBLOCK);
  43
  44         if ((bind(tempsock, (struct sockaddr *)&taddr, sizeof(taddr))) < 0) {
  45                 close(tempsock);
  46                 return -1;
  47         }
  48         return tempsock;
  49 }
  50
  51 int knix_Send(int hand, char *data, int len) {
  52         int i = 0, t;
  53
  54         while ((t = sendto(hand, data, len, 0, (struct sockaddr *)&kalinix_addr,
  55                         sizeof(kalinix_addr))) < 0) {
  56                 i++;
  57                 if (i > 10)
  58                         return 0;
  59         }
  60
  61         return t;
  62 }
  63
  64 int knix_Recv(int hand, char *data, int len) {
  65         struct sockaddr_in taddr;
  66         int tlen;
  67
  68         tlen = sizeof(taddr);
  69
  70         return recvfrom(hand, data, len, 0, (struct sockaddr *)&taddr, (unsigned int *)&tlen);
  71
  72 }
  73
  74 int knix_WaitforSocket(int hand, int timems) {
  75         fd_set set;
  76         struct timeval tv;
  77
  78         FD_ZERO(&set);
  79         FD_SET(hand, &set);
  80         tv.tv_sec = 0;
  81         // 100ms
  82         tv.tv_usec = timems * 1000;
  83         return select(hand + 1, &set, NULL, NULL, &tv);
  84 }
  85
  86 int knix_ReceivePacket(int hand, char *outdata, int *outlen, kaliaddr_ipx *from) {
  87         static char data[MAX_PACKET_SIZE];
  88         int len;
  89
  90         len = knix_Recv(hand, data, sizeof(data));
  91
  92         if (len <= 0) return 0;
  93
  94         switch (data[0]) {
  95 //              case 1: // open socket
  96 //                      break;
  97 //              case 2: // close socket
  98 //                      break;
  99                 case 3: // received data packet
 100                         if (len < 11) break;
 101                         if (!outdata)
 102                                 break;
 103                         from->sa_family = AF_IPX;
 104                         memcpy(from->sa_nodenum, &data[1], sizeof(from->sa_nodenum));
 105                         memset(from->sa_netnum, 0, sizeof(from->sa_netnum));
 106                         memcpy(&from->sa_socket, &data[9], sizeof(unsigned short));
 107                         memcpy(outdata, &data[11], len-11 > *outlen ? *outlen : len-11);
 108                         *outlen = len-11;
 109                         break;
 110                 case 4: // myipxaddress
 111                         if (len < 7) break;
 112                         memcpy(g_mynodenum, &data[1], 6);
 113                         break;
 114 //              case 5: // Init KaliNix connection
 115 //                      break;
 116                 case 6: // open response
 117                 case 7: // close response
 118                         if (len < 3) break;
 119 //                      memcpy(g_LastPort, &data[1], sizeof(g_LastPort))
 120                         break;
 121         }
 122
 123         return data[0];
 124
 125 }
 126
 127 int knix_GetMyAddress(void) {
 128         char initdata[1];
 129
 130         if (g_sockfd < 0) {
 131                 kalinix_addr.sin_family = AF_INET;
 132                 kalinix_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
 133                 kalinix_addr.sin_port = htons(4213);
 134
 135                 g_sockfd = knix_newSock();
 136         }
 137
 138         initdata[0] = 5; // Get Address
 139         knix_Send(g_sockfd, initdata, sizeof(initdata));
 140
 141         return 0;
 142
 143 }
 144
 145 int KaliSendPacket(int hand, char *data, int len, kaliaddr_ipx *to) {
 146         static char sendbuf[MAX_PACKET_SIZE+11];
 147 //              char    code; == 3
 148 //              char    sa_nodenum[6];
 149 //              char    dport[2];
 150 //              char    sport[2];
 151 //              char data[];
 152
 153         sendbuf[0] = 3;
 154         memcpy(&sendbuf[1], to->sa_nodenum, sizeof(to->sa_nodenum));
 155         memcpy(&sendbuf[7], &to->sa_socket, sizeof(to->sa_socket));
 156         memset(&sendbuf[9], 0, sizeof(to->sa_socket));
 157         len = len > MAX_PACKET_SIZE ? MAX_PACKET_SIZE : len;
 158         memcpy(&sendbuf[11], data, len);
 159
 160         if (!knix_Send(hand, sendbuf, len+11)){
 161                 return -1;
 162         }
 163         return len;
 164
 165 }
 166
 167 int KaliReceivePacket(int hand, char *data, int len, kaliaddr_ipx *from) {
 168         int newlen;
 169         int t;
 170
 171         newlen = len;
 172
 173         t = knix_ReceivePacket(hand, data, &newlen, from);
 174
 175         while (t != 0 && t != 3)
 176                 t = knix_ReceivePacket(hand, data, &newlen, from);
 177
 178         if (t == 3)
 179                 return newlen;
 180         else return -1;
 181
 182 }
 183
 184 int KaliGetNodeNum(kaliaddr_ipx *myaddr) {
 185         int tcount = 0;
 186
 187         if (g_sockfd < 0 && knix_GetMyAddress())
 188                 return -1;
 189
 190         while (tcount < 5) {
 191                 if (knix_WaitforSocket(g_sockfd, 100) > 0) {
 192                         if (knix_ReceivePacket(g_sockfd, NULL, 0, NULL) == 4)
 193                                 break;
 194                         continue;
 195                 }
 196                 knix_GetMyAddress();
 197                 tcount++;
 198         }
 199         if (tcount == 5)
 200                 return -1;
 201
 202         close(g_sockfd);
 203         g_sockfd = -1;
 204         memcpy(myaddr->sa_nodenum, g_mynodenum, sizeof(g_mynodenum));
 205
 206         return 0;
 207
 208 }
 209
 210 int KaliCloseSocket(int hand) {
 211         char opendata[3] = {2, 0, 0};
 212         int tcount = 0;
 213
 214         knix_Send(hand, opendata, sizeof(opendata));
 215
 216         while (tcount < 5) {
 217
 218                 if (knix_WaitforSocket(hand, 100) > 0) {
 219                         if (knix_ReceivePacket(hand, NULL, 0, NULL) == 7)
 220                                 break;
 221                         continue;
 222                 }
 223                 knix_Send(hand, opendata, sizeof(opendata));
 224                 tcount++;
 225         }
 226         close(hand);
 227         return 0;
 228
 229 }
 230
 231 int KaliOpenSocket(unsigned short port) {
 232         char opendata[16];
 233         int hand;
 234         int tcount = 0;
 235         long pid;
 236
 237         opendata[0] = 1; // open socket
 238         memcpy(&opendata[1], &port, sizeof(port));
 239         pid = (int)htonl(getpid());
 240         memcpy(&opendata[3], &pid, sizeof(pid));
 241         strncpy(&opendata[7], KALI_PROCESS_NAME, sizeof(KALI_PROCESS_NAME));
 242         opendata[15] = 0;
 243
 244         if ((hand = knix_newSock()) < 0)
 245                 return -1;
 246
 247         knix_Send(hand, opendata, sizeof(opendata));
 248
 249         while (tcount < 5) {
 250
 251                 if (knix_WaitforSocket(hand, 100) > 0) {
 252                         if (knix_ReceivePacket(hand, NULL, 0, NULL) == 6)
 253                                 break;
 254                         continue;
 255                 }
 256                 knix_Send(hand, opendata, sizeof(opendata));
 257                 tcount++;
 258         }
 259
 260         if (tcount == 5) {
 261                 close(hand);
 262                 return -1;
 263         }
 264
 265         return hand;
 266 }
 267