src/server/server.c

   1 /*
   2  * OpenDispense 2
   3  * UCC (University [of WA] Computer Club) Electronic Accounting System
   4  *
   5  * server.c - Client Server Code
   6  *
   7  * This file is licenced under the 3-clause BSD Licence. See the file
   8  * COPYING for full details.
   9  */
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include "common.h"
  13 #include <sys/socket.h>
  14 #include <netinet/in.h>
  15 #include <arpa/inet.h>
  16 #include <unistd.h>
  17 #include <string.h>
  18 #include <limits.h>
  19 #include <stdarg.h>
  20
  21 // HACKS
  22 #define HACK_TPG_NOAUTH 1
  23 #define HACK_ROOT_NOAUTH        1
  24
  25 #define DEBUG_TRACE_CLIENT      1
  26
  27 // Statistics
  28 #define MAX_CONNECTION_QUEUE    5
  29 #define INPUT_BUFFER_SIZE       256
  30
  31 #define HASH_TYPE       SHA1
  32 #define HASH_LENGTH     20
  33
  34 #define MSG_STR_TOO_LONG        "499 Command too long (limit "EXPSTR(INPUT_BUFFER_SIZE)")\n"
  35
  36 // === TYPES ===
  37 typedef struct sClient
  38 {
  39          int    Socket; // Client socket ID
  40          int    ID;     // Client ID
  41
  42          int    bIsTrusted;     // Is the connection from a trusted host/port
  43
  44         char    *Username;
  45         char    Salt[9];
  46
  47          int    UID;
  48          int    bIsAuthed;
  49 }       tClient;
  50
  51 // === PROTOTYPES ===
  52 void    Server_Start(void);
  53 void    Server_Cleanup(void);
  54 void    Server_HandleClient(int Socket, int bTrusted);
  55 char    *Server_ParseClientCommand(tClient *Client, char *CommandString);
  56 // --- Commands ---
  57 char    *Server_Cmd_USER(tClient *Client, char *Args);
  58 char    *Server_Cmd_PASS(tClient *Client, char *Args);
  59 char    *Server_Cmd_AUTOAUTH(tClient *Client, char *Args);
  60 char    *Server_Cmd_ENUMITEMS(tClient *Client, char *Args);
  61 char    *Server_Cmd_ITEMINFO(tClient *Client, char *Args);
  62 char    *Server_Cmd_DISPENSE(tClient *Client, char *Args);
  63 char    *Server_Cmd_GIVE(tClient *Client, char *Args);
  64 char    *Server_Cmd_ADD(tClient *Client, char *Args);
  65 char    *Server_Cmd_ENUMUSERS(tClient *Client, char *Args);
  66 char    *Server_Cmd_USERINFO(tClient *Client, char *Args);
  67 // --- Helpers ---
  68  int    sendf(int Socket, const char *Format, ...);
  69  int    GetUserAuth(const char *Salt, const char *Username, const uint8_t *Hash);
  70 void    HexBin(uint8_t *Dest, char *Src, int BufSize);
  71
  72 // === GLOBALS ===
  73  int    giServer_Port = 1020;
  74  int    giServer_NextClientID = 1;
  75 // - Commands
  76 struct sClientCommand {
  77         char    *Name;
  78         char    *(*Function)(tClient *Client, char *Arguments);
  79 }       gaServer_Commands[] = {
  80         {"USER", Server_Cmd_USER},
  81         {"PASS", Server_Cmd_PASS},
  82         {"AUTOAUTH", Server_Cmd_AUTOAUTH},
  83         {"ENUM_ITEMS", Server_Cmd_ENUMITEMS},
  84         {"ITEM_INFO", Server_Cmd_ITEMINFO},
  85         {"DISPENSE", Server_Cmd_DISPENSE},
  86         {"GIVE", Server_Cmd_GIVE},
  87         {"ADD", Server_Cmd_ADD},
  88         {"ENUM_USERS", Server_Cmd_ENUMUSERS},
  89         {"USER_INFO", Server_Cmd_USERINFO}
  90 };
  91 #define NUM_COMMANDS    (sizeof(gaServer_Commands)/sizeof(gaServer_Commands[0]))
  92  int    giServer_Socket;
  93
  94 // === CODE ===
  95 /**
  96  * \brief Open listenting socket and serve connections
  97  */
  98 void Server_Start(void)
  99 {
 100          int    client_socket;
 101         struct sockaddr_in      server_addr, client_addr;
 102
 103         atexit(Server_Cleanup);
 104
 105         // Create Server
 106         giServer_Socket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
 107         if( giServer_Socket < 0 ) {
 108                 fprintf(stderr, "ERROR: Unable to create server socket\n");
 109                 return ;
 110         }
 111
 112         // Make listen address
 113         memset(&server_addr, 0, sizeof(server_addr));
 114         server_addr.sin_family = AF_INET;       // Internet Socket
 115         server_addr.sin_addr.s_addr = htonl(INADDR_ANY);        // Listen on all interfaces
 116         server_addr.sin_port = htons(giServer_Port);    // Port
 117
 118         // Bind
 119         if( bind(giServer_Socket, (struct sockaddr *) &server_addr, sizeof(server_addr)) < 0 ) {
 120                 fprintf(stderr, "ERROR: Unable to bind to 0.0.0.0:%i\n", giServer_Port);
 121                 perror("Binding");
 122                 return ;
 123         }
 124
 125         // Listen
 126         if( listen(giServer_Socket, MAX_CONNECTION_QUEUE) < 0 ) {
 127                 fprintf(stderr, "ERROR: Unable to listen to socket\n");
 128                 perror("Listen");
 129                 return ;
 130         }
 131
 132         printf("Listening on 0.0.0.0:%i\n", giServer_Port);
 133
 134         for(;;)
 135         {
 136                 uint    len = sizeof(client_addr);
 137                  int    bTrusted = 0;
 138
 139                 client_socket = accept(giServer_Socket, (struct sockaddr *) &client_addr, &len);
 140                 if(client_socket < 0) {
 141                         fprintf(stderr, "ERROR: Unable to accept client connection\n");
 142                         return ;
 143                 }
 144
 145                 if(giDebugLevel >= 2) {
 146                         char    ipstr[INET_ADDRSTRLEN];
 147                         inet_ntop(AF_INET, &client_addr.sin_addr, ipstr, INET_ADDRSTRLEN);
 148                         printf("Client connection from %s:%i\n",
 149                                 ipstr, ntohs(client_addr.sin_port));
 150                 }
 151
 152                 // Trusted Connections
 153                 if( ntohs(client_addr.sin_port) < 1024 )
 154                 {
 155                         // TODO: Make this runtime configurable
 156                         switch( ntohl( client_addr.sin_addr.s_addr ) )
 157                         {
 158                         case 0x7F000001:        // 127.0.0.1    localhost
 159                         //case 0x825E0D00:      // 130.95.13.0
 160                         case 0x825E0D12:        // 130.95.13.18 mussel
 161                         case 0x825E0D17:        // 130.95.13.23 martello
 162                                 bTrusted = 1;
 163                                 break;
 164                         default:
 165                                 break;
 166                         }
 167                 }
 168
 169                 // TODO: Multithread this?
 170                 Server_HandleClient(client_socket, bTrusted);
 171
 172                 close(client_socket);
 173         }
 174 }
 175
 176 void Server_Cleanup(void)
 177 {
 178         printf("Close(%i)\n", giServer_Socket);
 179         close(giServer_Socket);
 180 }
 181
 182 /**
 183  * \brief Reads from a client socket and parses the command strings
 184  * \param Socket        Client socket number/handle
 185  * \param bTrusted      Is the client trusted?
 186  */
 187 void Server_HandleClient(int Socket, int bTrusted)
 188 {
 189         char    inbuf[INPUT_BUFFER_SIZE];
 190         char    *buf = inbuf;
 191          int    remspace = INPUT_BUFFER_SIZE-1;
 192          int    bytes = -1;
 193         tClient clientInfo = {0};
 194
 195         // Initialise Client info
 196         clientInfo.Socket = Socket;
 197         clientInfo.ID = giServer_NextClientID ++;
 198         clientInfo.bIsTrusted = bTrusted;
 199
 200         // Read from client
 201         /*
 202          * Notes:
 203          * - The `buf` and `remspace` variables allow a line to span several
 204          *   calls to recv(), if a line is not completed in one recv() call
 205          *   it is saved to the beginning of `inbuf` and `buf` is updated to
 206          *   the end of it.
 207          */
 208         while( (bytes = recv(Socket, buf, remspace, 0)) > 0 )
 209         {
 210                 char    *eol, *start;
 211                 buf[bytes] = '\0';      // Allow us to use stdlib string functions on it
 212
 213                 // Split by lines
 214                 start = inbuf;
 215                 while( (eol = strchr(start, '\n')) )
 216                 {
 217                         char    *ret;
 218                         *eol = '\0';
 219                         ret = Server_ParseClientCommand(&clientInfo, start);
 220
 221                         #if DEBUG_TRACE_CLIENT
 222                         printf("send : %s", ret);
 223                         #endif
 224
 225                         // `ret` is a string on the heap
 226                         send(Socket, ret, strlen(ret), 0);
 227                         free(ret);
 228                         start = eol + 1;
 229                 }
 230
 231                 // Check if there was an incomplete line
 232                 if( *start != '\0' ) {
 233                          int    tailBytes = bytes - (start-buf);
 234                         // Roll back in buffer
 235                         memcpy(inbuf, start, tailBytes);
 236                         remspace -= tailBytes;
 237                         if(remspace == 0) {
 238                                 send(Socket, MSG_STR_TOO_LONG, sizeof(MSG_STR_TOO_LONG), 0);
 239                                 buf = inbuf;
 240                                 remspace = INPUT_BUFFER_SIZE - 1;
 241                         }
 242                 }
 243                 else {
 244                         buf = inbuf;
 245                         remspace = INPUT_BUFFER_SIZE - 1;
 246                 }
 247         }
 248
 249         // Check for errors
 250         if( bytes < 0 ) {
 251                 fprintf(stderr, "ERROR: Unable to recieve from client on socket %i\n", Socket);
 252                 return ;
 253         }
 254
 255         if(giDebugLevel >= 2) {
 256                 printf("Client %i: Disconnected\n", clientInfo.ID);
 257         }
 258 }
 259
 260 /**
 261  * \brief Parses a client command and calls the required helper function
 262  * \param Client        Pointer to client state structure
 263  * \param CommandString Command from client (single line of the command)
 264  * \return Heap String to return to the client
 265  */
 266 char *Server_ParseClientCommand(tClient *Client, char *CommandString)
 267 {
 268         char    *space, *args;
 269          int    i;
 270
 271         // Split at first space
 272         space = strchr(CommandString, ' ');
 273         if(space == NULL) {
 274                 args = NULL;
 275         }
 276         else {
 277                 *space = '\0';
 278                 args = space + 1;
 279         }
 280
 281         // Find command
 282         for( i = 0; i < NUM_COMMANDS; i++ )
 283         {
 284                 if(strcmp(CommandString, gaServer_Commands[i].Name) == 0)
 285                         return gaServer_Commands[i].Function(Client, args);
 286         }
 287
 288         return strdup("400 Unknown Command\n");
 289 }
 290
 291 // ---
 292 // Commands
 293 // ---
 294 /**
 295  * \brief Set client username
 296  *
 297  * Usage: USER <username>
 298  */
 299 char *Server_Cmd_USER(tClient *Client, char *Args)
 300 {
 301         char    *ret;
 302
 303         // Debug!
 304         if( giDebugLevel )
 305                 printf("Client %i authenticating as '%s'\n", Client->ID, Args);
 306
 307         // Save username
 308         if(Client->Username)
 309                 free(Client->Username);
 310         Client->Username = strdup(Args);
 311
 312         #if USE_SALT
 313         // Create a salt (that changes if the username is changed)
 314         // Yes, I know, I'm a little paranoid, but who isn't?
 315         Client->Salt[0] = 0x21 + (rand()&0x3F);
 316         Client->Salt[1] = 0x21 + (rand()&0x3F);
 317         Client->Salt[2] = 0x21 + (rand()&0x3F);
 318         Client->Salt[3] = 0x21 + (rand()&0x3F);
 319         Client->Salt[4] = 0x21 + (rand()&0x3F);
 320         Client->Salt[5] = 0x21 + (rand()&0x3F);
 321         Client->Salt[6] = 0x21 + (rand()&0x3F);
 322         Client->Salt[7] = 0x21 + (rand()&0x3F);
 323
 324         // TODO: Also send hash type to use, (SHA1 or crypt according to [DAA])
 325         ret = mkstr("100 SALT %s\n", Client->Salt);
 326         #else
 327         ret = strdup("100 User Set\n");
 328         #endif
 329         return ret;
 330 }
 331
 332 /**
 333  * \brief Authenticate as a user
 334  *
 335  * Usage: PASS <hash>
 336  */
 337 char *Server_Cmd_PASS(tClient *Client, char *Args)
 338 {
 339         uint8_t clienthash[HASH_LENGTH] = {0};
 340
 341         // Read user's hash
 342         HexBin(clienthash, Args, HASH_LENGTH);
 343
 344         // TODO: Decrypt password passed
 345
 346         Client->UID = GetUserAuth(Client->Salt, Client->Username, clienthash);
 347
 348         if( Client->UID != -1 ) {
 349                 Client->bIsAuthed = 1;
 350                 return strdup("200 Auth OK\n");
 351         }
 352
 353         if( giDebugLevel ) {
 354                  int    i;
 355                 printf("Client %i: Password hash ", Client->ID);
 356                 for(i=0;i<HASH_LENGTH;i++)
 357                         printf("%02x", clienthash[i]&0xFF);
 358                 printf("\n");
 359         }
 360
 361         return strdup("401 Auth Failure\n");
 362 }
 363
 364 /**
 365  * \brief Authenticate as a user without a password
 366  *
 367  * Usage: AUTOAUTH <user>
 368  */
 369 char *Server_Cmd_AUTOAUTH(tClient *Client, char *Args)
 370 {
 371         char    *spos = strchr(Args, ' ');
 372         if(spos)        *spos = '\0';   // Remove characters after the ' '
 373
 374         // Check if trusted
 375         if( !Client->bIsTrusted ) {
 376                 if(giDebugLevel)
 377                         printf("Client %i: Untrusted client attempting to AUTOAUTH\n", Client->ID);
 378                 return strdup("401 Untrusted\n");
 379         }
 380
 381         // Get UID
 382         Client->UID = GetUserID( Args );
 383         if( Client->UID < 0 ) {
 384                 if(giDebugLevel)
 385                         printf("Client %i: Unknown user '%s'\n", Client->ID, Args);
 386                 return strdup("401 Auth Failure\n");
 387         }
 388
 389         if(giDebugLevel)
 390                 printf("Client %i: Authenticated as '%s' (%i)\n", Client->ID, Args, Client->UID);
 391
 392         return strdup("200 Auth OK\n");
 393 }
 394
 395 /**
 396  * \brief Enumerate the items that the server knows about
 397  */
 398 char *Server_Cmd_ENUMITEMS(tClient *Client, char *Args)
 399 {
 400          int    retLen;
 401          int    i;
 402         char    *ret;
 403
 404         retLen = snprintf(NULL, 0, "201 Items %i", giNumItems);
 405
 406         for( i = 0; i < giNumItems; i ++ )
 407         {
 408                 retLen += snprintf(NULL, 0, " %s:%i", gaItems[i].Handler->Name, gaItems[i].ID);
 409         }
 410
 411         ret = malloc(retLen+1);
 412         retLen = 0;
 413         retLen += sprintf(ret+retLen, "201 Items %i", giNumItems);
 414
 415         for( i = 0; i < giNumItems; i ++ ) {
 416                 retLen += sprintf(ret+retLen, " %s:%i", gaItems[i].Handler->Name, gaItems[i].ID);
 417         }
 418
 419         strcat(ret, "\n");
 420
 421         return ret;
 422 }
 423
 424 tItem *_GetItemFromString(char *String)
 425 {
 426         tHandler        *handler;
 427         char    *type = String;
 428         char    *colon = strchr(String, ':');
 429          int    num, i;
 430
 431         if( !colon ) {
 432                 return NULL;
 433         }
 434
 435         num = atoi(colon+1);
 436         *colon = '\0';
 437
 438         // Find handler
 439         handler = NULL;
 440         for( i = 0; i < giNumHandlers; i ++ )
 441         {
 442                 if( strcmp(gaHandlers[i]->Name, type) == 0) {
 443                         handler = gaHandlers[i];
 444                         break;
 445                 }
 446         }
 447         if( !handler ) {
 448                 return NULL;
 449         }
 450
 451         // Find item
 452         for( i = 0; i < giNumItems; i ++ )
 453         {
 454                 if( gaItems[i].Handler != handler )     continue;
 455                 if( gaItems[i].ID != num )      continue;
 456                 return &gaItems[i];
 457         }
 458         return NULL;
 459 }
 460
 461 /**
 462  * \brief Fetch information on a specific item
 463  */
 464 char *Server_Cmd_ITEMINFO(tClient *Client, char *Args)
 465 {
 466          int    retLen = 0;
 467         char    *ret;
 468         tItem   *item = _GetItemFromString(Args);
 469
 470         if( !item ) {
 471                 return strdup("406 Bad Item ID\n");
 472         }
 473
 474         // Create return
 475         retLen = snprintf(NULL, 0, "202 Item %s:%i %i %s\n",
 476                 item->Handler->Name, item->ID, item->Price, item->Name);
 477         ret = malloc(retLen+1);
 478         sprintf(ret, "202 Item %s:%i %i %s\n",
 479                 item->Handler->Name, item->ID, item->Price, item->Name);
 480
 481         return ret;
 482 }
 483
 484 char *Server_Cmd_DISPENSE(tClient *Client, char *Args)
 485 {
 486         tItem   *item;
 487          int    ret;
 488         if( !Client->bIsAuthed )        return strdup("401 Not Authenticated\n");
 489
 490         item = _GetItemFromString(Args);
 491         if( !item ) {
 492                 return strdup("406 Bad Item ID\n");
 493         }
 494
 495         switch( ret = DispenseItem( Client->UID, item ) )
 496         {
 497         case 0: return strdup("200 Dispense OK\n");
 498         case 1: return strdup("501 Unable to dispense\n");
 499         case 2: return strdup("402 Poor You\n");
 500         default:
 501                 return strdup("500 Dispense Error\n");
 502         }
 503 }
 504
 505 char *Server_Cmd_GIVE(tClient *Client, char *Args)
 506 {
 507         char    *recipient, *ammount, *reason;
 508          int    uid, iAmmount;
 509
 510         if( !Client->bIsAuthed )        return strdup("401 Not Authenticated\n");
 511
 512         recipient = Args;
 513
 514         ammount = strchr(Args, ' ');
 515         if( !ammount )  return strdup("407 Invalid Argument, expected 3 parameters, 1 encountered\n");
 516         *ammount = '\0';
 517         ammount ++;
 518
 519         reason = strchr(ammount, ' ');
 520         if( !reason )   return strdup("407 Invalid Argument, expected 3 parameters, 2 encountered\n");
 521         *reason = '\0';
 522         reason ++;
 523
 524         // Get recipient
 525         uid = GetUserID(recipient);
 526         if( uid == -1 ) return strdup("404 Invalid target user");
 527
 528         // Parse ammount
 529         iAmmount = atoi(ammount);
 530         if( iAmmount <= 0 )     return strdup("407 Invalid Argument, ammount must be > zero\n");
 531
 532         // Do give
 533         switch( DispenseGive(Client->UID, uid, iAmmount, reason) )
 534         {
 535         case 0:
 536                 return strdup("200 Give OK\n");
 537         case 2:
 538                 return strdup("402 Poor You\n");
 539         default:
 540                 return strdup("500 Unknown error\n");
 541         }
 542 }
 543
 544 char *Server_Cmd_ADD(tClient *Client, char *Args)
 545 {
 546         char    *user, *ammount, *reason;
 547          int    uid, iAmmount;
 548
 549         if( !Client->bIsAuthed )        return strdup("401 Not Authenticated\n");
 550
 551         user = Args;
 552
 553         ammount = strchr(Args, ' ');
 554         if( !ammount )  return strdup("407 Invalid Argument, expected 3 parameters, 1 encountered\n");
 555         *ammount = '\0';
 556         ammount ++;
 557
 558         reason = strchr(ammount, ' ');
 559         if( !reason )   return strdup("407 Invalid Argument, expected 3 parameters, 2 encountered\n");
 560         *reason = '\0';
 561         reason ++;
 562
 563         // TODO: Check if the current user is in coke/higher
 564
 565         // Get recipient
 566         uid = GetUserID(user);
 567         if( uid == -1 ) return strdup("404 Invalid user");
 568
 569         // Parse ammount
 570         iAmmount = atoi(ammount);
 571         if( iAmmount == 0 && ammount[0] != '0' )
 572                 return strdup("407 Invalid Argument\n");
 573
 574         // Do give
 575         switch( DispenseAdd(uid, Client->UID, iAmmount, reason) )
 576         {
 577         case 0:
 578                 return strdup("200 Add OK\n");
 579         case 2:
 580                 return strdup("402 Poor Guy\n");
 581         default:
 582                 return strdup("500 Unknown error\n");
 583         }
 584 }
 585
 586 char *Server_Cmd_ENUMUSERS(tClient *Client, char *Args)
 587 {
 588          int    i, numRet = 0;
 589          int    maxBal = INT_MAX, minBal = INT_MIN;
 590          int    numUsr = GetMaxID();
 591
 592         // Parse arguments
 593         //minBal = atoi(Args);
 594
 595         // Get return number
 596         for( i = 0; i < numUsr; i ++ )
 597         {
 598                 int bal = GetBalance(i);
 599
 600                 if( bal == INT_MIN )    continue;
 601
 602                 if( bal < minBal )      continue;
 603                 if( bal > maxBal )      continue;
 604
 605                 numRet ++;
 606         }
 607
 608         // Send count
 609         sendf(Client->Socket, "201 Users %i\n", numRet);
 610
 611         for( i = 0; i < numUsr; i ++ )
 612         {
 613                 int bal = GetBalance(i);
 614
 615                 if( bal == INT_MIN )    continue;
 616
 617                 if( bal < minBal )      continue;
 618                 if( bal > maxBal )      continue;
 619
 620                 // TODO: User flags
 621                 sendf(Client->Socket, "202 User %s %i user\n", GetUserName(i), GetBalance(i));
 622         }
 623
 624         return strdup("200 List End\n");
 625 }
 626
 627 char *Server_Cmd_USERINFO(tClient *Client, char *Args)
 628 {
 629          int    uid;
 630         char    *user = Args;
 631         char    *space;
 632
 633         space = strchr(user, ' ');
 634         if(space)       *space = '\0';
 635
 636         // Get recipient
 637         uid = GetUserID(user);
 638         if( uid == -1 ) return strdup("404 Invalid user");
 639
 640         // TODO: User flags/type
 641         return mkstr("202 User %s %i user\n", user, GetBalance(uid));
 642 }
 643
 644 /**
 645  * \brief Authenticate a user
 646  * \return User ID, or -1 if authentication failed
 647  */
 648 int GetUserAuth(const char *Salt, const char *Username, const uint8_t *ProvidedHash)
 649 {
 650         #if 0
 651         uint8_t h[20];
 652          int    ofs = strlen(Username) + strlen(Salt);
 653         char    input[ ofs + 40 + 1];
 654         char    tmp[4 + strlen(Username) + 1];  // uid=%s
 655         #endif
 656
 657         #if HACK_TPG_NOAUTH
 658         if( strcmp(Username, "tpg") == 0 )
 659                 return GetUserID("tpg");
 660         #endif
 661         #if HACK_ROOT_NOAUTH
 662         if( strcmp(Username, "root") == 0 )
 663                 return GetUserID("root");
 664         #endif
 665
 666         #if 0
 667         //
 668         strcpy(input, Username);
 669         strcpy(input, Salt);
 670         // TODO: Get user's SHA-1 hash
 671         sprintf(tmp, "uid=%s", Username);
 672         ldap_search_s(ld, "", LDAP_SCOPE_BASE, tmp, "userPassword", 0, res);
 673
 674         sprintf(input+ofs, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
 675                 h[ 0], h[ 1], h[ 2], h[ 3], h[ 4], h[ 5], h[ 6], h[ 7], h[ 8], h[ 9],
 676                 h[10], h[11], h[12], h[13], h[14], h[15], h[16], h[17], h[18], h[19]
 677                 );
 678         // Then create the hash from the provided salt
 679         // Compare that with the provided hash
 680         #endif
 681
 682         return -1;
 683 }
 684
 685 // --- INTERNAL HELPERS ---
 686 int sendf(int Socket, const char *Format, ...)
 687 {
 688         va_list args;
 689          int    len;
 690
 691         va_start(args, Format);
 692         len = vsnprintf(NULL, 0, Format, args);
 693         va_end(args);
 694
 695         {
 696                 char    buf[len+1];
 697                 va_start(args, Format);
 698                 vsnprintf(buf, len+1, Format, args);
 699                 va_end(args);
 700
 701                 #if DEBUG_TRACE_CLIENT
 702                 printf("sendf: %s", buf);
 703                 #endif
 704
 705                 return send(Socket, buf, len, 0);
 706         }
 707 }
 708
 709 // TODO: Move to another file
 710 void HexBin(uint8_t *Dest, char *Src, int BufSize)
 711 {
 712          int    i;
 713         for( i = 0; i < BufSize; i ++ )
 714         {
 715                 uint8_t val = 0;
 716
 717                 if('0' <= *Src && *Src <= '9')
 718                         val |= (*Src-'0') << 4;
 719                 else if('A' <= *Src && *Src <= 'F')
 720                         val |= (*Src-'A'+10) << 4;
 721                 else if('a' <= *Src && *Src <= 'f')
 722                         val |= (*Src-'a'+10) << 4;
 723                 else
 724                         break;
 725                 Src ++;
 726
 727                 if('0' <= *Src && *Src <= '9')
 728                         val |= (*Src-'0');
 729                 else if('A' <= *Src && *Src <= 'F')
 730                         val |= (*Src-'A'+10);
 731                 else if('a' <= *Src && *Src <= 'f')
 732                         val |= (*Src-'a'+10);
 733                 else
 734                         break;
 735                 Src ++;
 736
 737                 Dest[i] = val;
 738         }
 739         for( ; i < BufSize; i++ )
 740                 Dest[i] = 0;
 741 }
 742
 743 /**
 744  * \brief Decode a Base64 value
 745  */
 746 int UnBase64(uint8_t *Dest, char *Src, int BufSize)
 747 {
 748         uint32_t        val;
 749          int    i, j;
 750         char    *start_src = Src;
 751
 752         for( i = 0; i+2 < BufSize; i += 3 )
 753         {
 754                 val = 0;
 755                 for( j = 0; j < 4; j++, Src ++ ) {
 756                         if('A' <= *Src && *Src <= 'Z')
 757                                 val |= (*Src - 'A') << ((3-j)*6);
 758                         else if('a' <= *Src && *Src <= 'z')
 759                                 val |= (*Src - 'a' + 26) << ((3-j)*6);
 760                         else if('0' <= *Src && *Src <= '9')
 761                                 val |= (*Src - '0' + 52) << ((3-j)*6);
 762                         else if(*Src == '+')
 763                                 val |= 62 << ((3-j)*6);
 764                         else if(*Src == '/')
 765                                 val |= 63 << ((3-j)*6);
 766                         else if(!*Src)
 767                                 break;
 768                         else if(*Src != '=')
 769                                 j --;   // Ignore invalid characters
 770                 }
 771                 Dest[i  ] = (val >> 16) & 0xFF;
 772                 Dest[i+1] = (val >> 8) & 0xFF;
 773                 Dest[i+2] = val & 0xFF;
 774                 if(j != 4)      break;
 775         }
 776
 777         // Finish things off
 778         if(i   < BufSize)
 779                 Dest[i] = (val >> 16) & 0xFF;
 780         if(i+1 < BufSize)
 781                 Dest[i+1] = (val >> 8) & 0xFF;
 782
 783         return Src - start_src;
 784 }