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 = (int)sendto(hand, data, len, 0, (struct sockaddr *)&kalinix_addr, sizeof(kalinix_addr))) < 0) {
  55                 i++;
  56                 if (i > 10)
  57                         return 0;
  58         }
  59
  60         return t;
  61 }
  62
  63 int knix_Recv(int hand, char *data, int len) {
  64         struct sockaddr_in taddr;
  65         socklen_t tlen;
  66
  67         tlen = sizeof(taddr);
  68
  69         return (int)recvfrom(hand, data, len, 0, (struct sockaddr *)&taddr, (unsigned int *)&tlen);
  70 }
  71
  72 int knix_WaitforSocket(int hand, int timems) {
  73         fd_set set;
  74         struct timeval tv;
  75
  76         FD_ZERO(&set);
  77         FD_SET(hand, &set);
  78         tv.tv_sec = 0;
  79         // 100ms
  80         tv.tv_usec = timems * 1000;
  81         return select(hand + 1, &set, NULL, NULL, &tv);
  82 }
  83
  84 int knix_ReceivePacket(int hand, char *outdata, int *outlen, kaliaddr_ipx *from) {
  85         static char data[MAX_PACKET_SIZE];
  86         int len;
  87
  88         len = knix_Recv(hand, data, sizeof(data));
  89
  90         if (len <= 0) return 0;
  91
  92         switch (data[0]) {
  93 //              case 1: // open socket
  94 //                      break;
  95 //              case 2: // close socket
  96 //                      break;
  97                 case 3: // received data packet
  98                         if (len < 11) break;
  99                         if (!outdata)
 100                                 break;
 101                         from->sa_family = AF_IPX;
 102                         memcpy(from->sa_nodenum, &data[1], sizeof(from->sa_nodenum));
 103                         memset(from->sa_netnum, 0, sizeof(from->sa_netnum));
 104                         memcpy(&from->sa_socket, &data[9], sizeof(unsigned short));
 105                         memcpy(outdata, &data[11], len-11 > *outlen ? *outlen : len-11);
 106                         *outlen = len-11;
 107                         break;
 108                 case 4: // myipxaddress
 109                         if (len < 7) break;
 110                         memcpy(g_mynodenum, &data[1], 6);
 111                         break;
 112 //              case 5: // Init KaliNix connection
 113 //                      break;
 114                 case 6: // open response
 115                 case 7: // close response
 116                         if (len < 3) break;
 117 //                      memcpy(g_LastPort, &data[1], sizeof(g_LastPort))
 118                         break;
 119         }
 120
 121         return data[0];
 122
 123 }
 124
 125 int knix_GetMyAddress(void) {
 126         char initdata[1];
 127
 128         if (g_sockfd < 0) {
 129                 kalinix_addr.sin_family = AF_INET;
 130                 kalinix_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
 131                 kalinix_addr.sin_port = htons(4213);
 132
 133                 g_sockfd = knix_newSock();
 134         }
 135
 136         initdata[0] = 5; // Get Address
 137         knix_Send(g_sockfd, initdata, sizeof(initdata));
 138
 139         return 0;
 140
 141 }
 142
 143 int KaliSendPacket(int hand, char *data, int len, kaliaddr_ipx *to) {
 144         static char sendbuf[MAX_PACKET_SIZE+11];
 145 //              char    code; == 3
 146 //              char    sa_nodenum[6];
 147 //              char    dport[2];
 148 //              char    sport[2];
 149 //              char data[];
 150
 151         sendbuf[0] = 3;
 152         memcpy(&sendbuf[1], to->sa_nodenum, sizeof(to->sa_nodenum));
 153         memcpy(&sendbuf[7], &to->sa_socket, sizeof(to->sa_socket));
 154         memset(&sendbuf[9], 0, sizeof(to->sa_socket));
 155         len = len > MAX_PACKET_SIZE ? MAX_PACKET_SIZE : len;
 156         memcpy(&sendbuf[11], data, len);
 157
 158         if (!knix_Send(hand, sendbuf, len+11)){
 159                 return -1;
 160         }
 161         return len;
 162
 163 }
 164
 165 int KaliReceivePacket(int hand, char *data, int len, kaliaddr_ipx *from) {
 166         int newlen;
 167         int t;
 168
 169         newlen = len;
 170
 171         t = knix_ReceivePacket(hand, data, &newlen, from);
 172
 173         while (t != 0 && t != 3)
 174                 t = knix_ReceivePacket(hand, data, &newlen, from);
 175
 176         if (t == 3)
 177                 return newlen;
 178         else return -1;
 179
 180 }
 181
 182 int KaliGetNodeNum(kaliaddr_ipx *myaddr) {
 183         int tcount = 0;
 184
 185         if (g_sockfd < 0 && knix_GetMyAddress())
 186                 return -1;
 187
 188         while (tcount < 5) {
 189                 if (knix_WaitforSocket(g_sockfd, 100) > 0) {
 190                         if (knix_ReceivePacket(g_sockfd, NULL, 0, NULL) == 4)
 191                                 break;
 192                         continue;
 193                 }
 194                 knix_GetMyAddress();
 195                 tcount++;
 196         }
 197         if (tcount == 5)
 198                 return -1;
 199
 200         close(g_sockfd);
 201         g_sockfd = -1;
 202         memcpy(myaddr->sa_nodenum, g_mynodenum, sizeof(g_mynodenum));
 203
 204         return 0;
 205
 206 }
 207
 208 int KaliCloseSocket(int hand) {
 209         char opendata[3] = {2, 0, 0};
 210         int tcount = 0;
 211
 212         knix_Send(hand, opendata, sizeof(opendata));
 213
 214         while (tcount < 5) {
 215
 216                 if (knix_WaitforSocket(hand, 100) > 0) {
 217                         if (knix_ReceivePacket(hand, NULL, 0, NULL) == 7)
 218                                 break;
 219                         continue;
 220                 }
 221                 knix_Send(hand, opendata, sizeof(opendata));
 222                 tcount++;
 223         }
 224         close(hand);
 225         return 0;
 226
 227 }
 228
 229 int KaliOpenSocket(unsigned short port) {
 230         char opendata[16];
 231         int hand;
 232         int tcount = 0;
 233         long pid;
 234
 235         opendata[0] = 1; // open socket
 236         memcpy(&opendata[1], &port, sizeof(port));
 237         pid = (int)htonl(getpid());
 238         memcpy(&opendata[3], &pid, sizeof(pid));
 239         strncpy(&opendata[7], KALI_PROCESS_NAME, sizeof(char)*8);
 240         opendata[15] = 0;
 241
 242         if ((hand = knix_newSock()) < 0)
 243                 return -1;
 244
 245         knix_Send(hand, opendata, sizeof(opendata));
 246
 247         while (tcount < 5) {
 248
 249                 if (knix_WaitforSocket(hand, 100) > 0) {
 250                         if (knix_ReceivePacket(hand, NULL, 0, NULL) == 6)
 251                                 break;
 252                         continue;
 253                 }
 254                 knix_Send(hand, opendata, sizeof(opendata));
 255                 tcount++;
 256         }
 257
 258         if (tcount == 5) {
 259                 close(hand);
 260                 return -1;
 261         }
 262
 263         return hand;
 264 }
 265