src/trunnel/socks5.c

   1 /* socks5.c -- generated by Trunnel v1.5.3.
   2  * https://gitweb.torproject.org/trunnel.git
   3  * You probably shouldn't edit this file.
   4  */
   5 #include <stdlib.h>
   6 #include "trunnel-impl.h"
   7
   8 #include "socks5.h"
   9
  10 #define TRUNNEL_SET_ERROR_CODE(obj) \
  11   do {                              \
  12     (obj)->trunnel_error_code_ = 1; \
  13   } while (0)
  14
  15 #if defined(__COVERITY__) || defined(__clang_analyzer__)
  16 /* If we're running a static analysis tool, we don't want it to complain
  17  * that some of our remaining-bytes checks are dead-code. */
  18 int socks_deadcode_dummy__ = 0;
  19 #define OR_DEADCODE_DUMMY || socks_deadcode_dummy__
  20 #else
  21 #define OR_DEADCODE_DUMMY
  22 #endif
  23
  24 #define CHECK_REMAINING(nbytes, label)                           \
  25   do {                                                           \
  26     if (remaining < (nbytes) OR_DEADCODE_DUMMY) {                \
  27       goto label;                                                \
  28     }                                                            \
  29   } while (0)
  30
  31 domainname_t *
  32 domainname_new(void)
  33 {
  34   domainname_t *val = trunnel_calloc(1, sizeof(domainname_t));
  35   if (NULL == val)
  36     return NULL;
  37   return val;
  38 }
  39
  40 /** Release all storage held inside 'obj', but do not free 'obj'.
  41  */
  42 static void
  43 domainname_clear(domainname_t *obj)
  44 {
  45   (void) obj;
  46   TRUNNEL_DYNARRAY_WIPE(&obj->name);
  47   TRUNNEL_DYNARRAY_CLEAR(&obj->name);
  48 }
  49
  50 void
  51 domainname_free(domainname_t *obj)
  52 {
  53   if (obj == NULL)
  54     return;
  55   domainname_clear(obj);
  56   trunnel_memwipe(obj, sizeof(domainname_t));
  57   trunnel_free_(obj);
  58 }
  59
  60 uint8_t
  61 domainname_get_len(const domainname_t *inp)
  62 {
  63   return inp->len;
  64 }
  65 int
  66 domainname_set_len(domainname_t *inp, uint8_t val)
  67 {
  68   inp->len = val;
  69   return 0;
  70 }
  71 size_t
  72 domainname_getlen_name(const domainname_t *inp)
  73 {
  74   return TRUNNEL_DYNARRAY_LEN(&inp->name);
  75 }
  76
  77 char
  78 domainname_get_name(domainname_t *inp, size_t idx)
  79 {
  80   return TRUNNEL_DYNARRAY_GET(&inp->name, idx);
  81 }
  82
  83 char
  84 domainname_getconst_name(const domainname_t *inp, size_t idx)
  85 {
  86   return domainname_get_name((domainname_t*)inp, idx);
  87 }
  88 int
  89 domainname_set_name(domainname_t *inp, size_t idx, char elt)
  90 {
  91   TRUNNEL_DYNARRAY_SET(&inp->name, idx, elt);
  92   return 0;
  93 }
  94 int
  95 domainname_add_name(domainname_t *inp, char elt)
  96 {
  97 #if SIZE_MAX >= UINT8_MAX
  98   if (inp->name.n_ == UINT8_MAX)
  99     goto trunnel_alloc_failed;
 100 #endif
 101   TRUNNEL_DYNARRAY_ADD(char, &inp->name, elt, {});
 102   return 0;
 103  trunnel_alloc_failed:
 104   TRUNNEL_SET_ERROR_CODE(inp);
 105   return -1;
 106 }
 107
 108 char *
 109 domainname_getarray_name(domainname_t *inp)
 110 {
 111   return inp->name.elts_;
 112 }
 113 const char  *
 114 domainname_getconstarray_name(const domainname_t *inp)
 115 {
 116   return (const char  *)domainname_getarray_name((domainname_t*)inp);
 117 }
 118 int
 119 domainname_setlen_name(domainname_t *inp, size_t newlen)
 120 {
 121 #if UINT8_MAX < SIZE_MAX
 122   if (newlen > UINT8_MAX)
 123     goto trunnel_alloc_failed;
 124 #endif
 125   return trunnel_string_setlen(&inp->name, newlen,
 126             &inp->trunnel_error_code_);
 127  trunnel_alloc_failed:
 128   TRUNNEL_SET_ERROR_CODE(inp);
 129   return -1;
 130 }
 131 const char *
 132 domainname_getstr_name(domainname_t *inp)
 133 {
 134   return trunnel_string_getstr(&inp->name);
 135 }
 136 int
 137 domainname_setstr0_name(domainname_t *inp, const char *val, size_t len)
 138 {
 139 #if UINT8_MAX < SIZE_MAX
 140   if (len > UINT8_MAX) {
 141     TRUNNEL_SET_ERROR_CODE(inp);
 142     return -1;
 143   }
 144 #endif
 145   return trunnel_string_setstr0(&inp->name, val, len, &inp->trunnel_error_code_);
 146 }
 147 int
 148 domainname_setstr_name(domainname_t *inp, const char *val)
 149 {
 150   return domainname_setstr0_name(inp, val, strlen(val));
 151 }
 152 const char *
 153 domainname_check(const domainname_t *obj)
 154 {
 155   if (obj == NULL)
 156     return "Object was NULL";
 157   if (obj->trunnel_error_code_)
 158     return "A set function failed on this object";
 159   if (TRUNNEL_DYNARRAY_LEN(&obj->name) != obj->len)
 160     return "Length mismatch for name";
 161   return NULL;
 162 }
 163
 164 ssize_t
 165 domainname_encoded_len(const domainname_t *obj)
 166 {
 167   ssize_t result = 0;
 168
 169   if (NULL != domainname_check(obj))
 170      return -1;
 171
 172
 173   /* Length of u8 len */
 174   result += 1;
 175
 176   /* Length of char name[len] */
 177   result += TRUNNEL_DYNARRAY_LEN(&obj->name);
 178   return result;
 179 }
 180 int
 181 domainname_clear_errors(domainname_t *obj)
 182 {
 183   int r = obj->trunnel_error_code_;
 184   obj->trunnel_error_code_ = 0;
 185   return r;
 186 }
 187 ssize_t
 188 domainname_encode(uint8_t *output, const size_t avail, const domainname_t *obj)
 189 {
 190   ssize_t result = 0;
 191   size_t written = 0;
 192   uint8_t *ptr = output;
 193   const char *msg;
 194 #ifdef TRUNNEL_CHECK_ENCODED_LEN
 195   const ssize_t encoded_len = domainname_encoded_len(obj);
 196 #endif
 197
 198   if (NULL != (msg = domainname_check(obj)))
 199     goto check_failed;
 200
 201 #ifdef TRUNNEL_CHECK_ENCODED_LEN
 202   trunnel_assert(encoded_len >= 0);
 203 #endif
 204
 205   /* Encode u8 len */
 206   trunnel_assert(written <= avail);
 207   if (avail - written < 1)
 208     goto truncated;
 209   trunnel_set_uint8(ptr, (obj->len));
 210   written += 1; ptr += 1;
 211
 212   /* Encode char name[len] */
 213   {
 214     size_t elt_len = TRUNNEL_DYNARRAY_LEN(&obj->name);
 215     trunnel_assert(obj->len == elt_len);
 216     trunnel_assert(written <= avail);
 217     if (avail - written < elt_len)
 218       goto truncated;
 219     if (elt_len)
 220       memcpy(ptr, obj->name.elts_, elt_len);
 221     written += elt_len; ptr += elt_len;
 222   }
 223
 224
 225   trunnel_assert(ptr == output + written);
 226 #ifdef TRUNNEL_CHECK_ENCODED_LEN
 227   {
 228     trunnel_assert(encoded_len >= 0);
 229     trunnel_assert((size_t)encoded_len == written);
 230   }
 231
 232 #endif
 233
 234   return written;
 235
 236  truncated:
 237   result = -2;
 238   goto fail;
 239  check_failed:
 240   (void)msg;
 241   result = -1;
 242   goto fail;
 243  fail:
 244   trunnel_assert(result < 0);
 245   return result;
 246 }
 247
 248 /** As domainname_parse(), but do not allocate the output object.
 249  */
 250 static ssize_t
 251 domainname_parse_into(domainname_t *obj, const uint8_t *input, const size_t len_in)
 252 {
 253   const uint8_t *ptr = input;
 254   size_t remaining = len_in;
 255   ssize_t result = 0;
 256   (void)result;
 257
 258   /* Parse u8 len */
 259   CHECK_REMAINING(1, truncated);
 260   obj->len = (trunnel_get_uint8(ptr));
 261   remaining -= 1; ptr += 1;
 262
 263   /* Parse char name[len] */
 264   CHECK_REMAINING(obj->len, truncated);
 265   if (domainname_setstr0_name(obj, (const char*)ptr, obj->len))
 266     goto fail;
 267   ptr += obj->len; remaining -= obj->len;
 268   trunnel_assert(ptr + remaining == input + len_in);
 269   return len_in - remaining;
 270
 271  truncated:
 272   return -2;
 273  fail:
 274   result = -1;
 275   return result;
 276 }
 277
 278 ssize_t
 279 domainname_parse(domainname_t **output, const uint8_t *input, const size_t len_in)
 280 {
 281   ssize_t result;
 282   *output = domainname_new();
 283   if (NULL == *output)
 284     return -1;
 285   result = domainname_parse_into(*output, input, len_in);
 286   if (result < 0) {
 287     domainname_free(*output);
 288     *output = NULL;
 289   }
 290   return result;
 291 }
 292 socks4_client_request_t *
 293 socks4_client_request_new(void)
 294 {
 295   socks4_client_request_t *val = trunnel_calloc(1, sizeof(socks4_client_request_t));
 296   if (NULL == val)
 297     return NULL;
 298   val->version = 4;
 299   val->command = CMD_BIND;
 300   return val;
 301 }
 302
 303 /** Release all storage held inside 'obj', but do not free 'obj'.
 304  */
 305 static void
 306 socks4_client_request_clear(socks4_client_request_t *obj)
 307 {
 308   (void) obj;
 309   trunnel_wipestr(obj->username);
 310   trunnel_free(obj->username);
 311   trunnel_wipestr(obj->socks4a_addr_hostname);
 312   trunnel_free(obj->socks4a_addr_hostname);
 313 }
 314
 315 void
 316 socks4_client_request_free(socks4_client_request_t *obj)
 317 {
 318   if (obj == NULL)
 319     return;
 320   socks4_client_request_clear(obj);
 321   trunnel_memwipe(obj, sizeof(socks4_client_request_t));
 322   trunnel_free_(obj);
 323 }
 324
 325 uint8_t
 326 socks4_client_request_get_version(const socks4_client_request_t *inp)
 327 {
 328   return inp->version;
 329 }
 330 int
 331 socks4_client_request_set_version(socks4_client_request_t *inp, uint8_t val)
 332 {
 333   if (! ((val == 4))) {
 334      TRUNNEL_SET_ERROR_CODE(inp);
 335      return -1;
 336   }
 337   inp->version = val;
 338   return 0;
 339 }
 340 uint8_t
 341 socks4_client_request_get_command(const socks4_client_request_t *inp)
 342 {
 343   return inp->command;
 344 }
 345 int
 346 socks4_client_request_set_command(socks4_client_request_t *inp, uint8_t val)
 347 {
 348   if (! ((val == CMD_BIND || val == CMD_CONNECT || val == CMD_RESOLVE || val == CMD_RESOLVE_PTR))) {
 349      TRUNNEL_SET_ERROR_CODE(inp);
 350      return -1;
 351   }
 352   inp->command = val;
 353   return 0;
 354 }
 355 uint16_t
 356 socks4_client_request_get_port(const socks4_client_request_t *inp)
 357 {
 358   return inp->port;
 359 }
 360 int
 361 socks4_client_request_set_port(socks4_client_request_t *inp, uint16_t val)
 362 {
 363   inp->port = val;
 364   return 0;
 365 }
 366 uint32_t
 367 socks4_client_request_get_addr(const socks4_client_request_t *inp)
 368 {
 369   return inp->addr;
 370 }
 371 int
 372 socks4_client_request_set_addr(socks4_client_request_t *inp, uint32_t val)
 373 {
 374   inp->addr = val;
 375   return 0;
 376 }
 377 const char *
 378 socks4_client_request_get_username(const socks4_client_request_t *inp)
 379 {
 380   return inp->username;
 381 }
 382 int
 383 socks4_client_request_set_username(socks4_client_request_t *inp, const char *val)
 384 {
 385   trunnel_free(inp->username);
 386   if (NULL == (inp->username = trunnel_strdup(val))) {
 387     TRUNNEL_SET_ERROR_CODE(inp);
 388     return -1;
 389   }
 390   return 0;
 391 }
 392 const char *
 393 socks4_client_request_get_socks4a_addr_hostname(const socks4_client_request_t *inp)
 394 {
 395   return inp->socks4a_addr_hostname;
 396 }
 397 int
 398 socks4_client_request_set_socks4a_addr_hostname(socks4_client_request_t *inp, const char *val)
 399 {
 400   trunnel_free(inp->socks4a_addr_hostname);
 401   if (NULL == (inp->socks4a_addr_hostname = trunnel_strdup(val))) {
 402     TRUNNEL_SET_ERROR_CODE(inp);
 403     return -1;
 404   }
 405   return 0;
 406 }
 407 const char *
 408 socks4_client_request_check(const socks4_client_request_t *obj)
 409 {
 410   if (obj == NULL)
 411     return "Object was NULL";
 412   if (obj->trunnel_error_code_)
 413     return "A set function failed on this object";
 414   if (! (obj->version == 4))
 415     return "Integer out of bounds";
 416   if (! (obj->command == CMD_BIND || obj->command == CMD_CONNECT || obj->command == CMD_RESOLVE || obj->command == CMD_RESOLVE_PTR))
 417     return "Integer out of bounds";
 418   if (NULL == obj->username)
 419     return "Missing username";
 420   switch (obj->addr) {
 421
 422     case 1:
 423     case 2:
 424     case 3:
 425     case 4:
 426     case 5:
 427     case 6:
 428     case 7:
 429     case 8:
 430     case 9:
 431     case 10:
 432     case 11:
 433     case 12:
 434     case 13:
 435     case 14:
 436     case 15:
 437     case 16:
 438     case 17:
 439     case 18:
 440     case 19:
 441     case 20:
 442     case 21:
 443     case 22:
 444     case 23:
 445     case 24:
 446     case 25:
 447     case 26:
 448     case 27:
 449     case 28:
 450     case 29:
 451     case 30:
 452     case 31:
 453     case 32:
 454     case 33:
 455     case 34:
 456     case 35:
 457     case 36:
 458     case 37:
 459     case 38:
 460     case 39:
 461     case 40:
 462     case 41:
 463     case 42:
 464     case 43:
 465     case 44:
 466     case 45:
 467     case 46:
 468     case 47:
 469     case 48:
 470     case 49:
 471     case 50:
 472     case 51:
 473     case 52:
 474     case 53:
 475     case 54:
 476     case 55:
 477     case 56:
 478     case 57:
 479     case 58:
 480     case 59:
 481     case 60:
 482     case 61:
 483     case 62:
 484     case 63:
 485     case 64:
 486     case 65:
 487     case 66:
 488     case 67:
 489     case 68:
 490     case 69:
 491     case 70:
 492     case 71:
 493     case 72:
 494     case 73:
 495     case 74:
 496     case 75:
 497     case 76:
 498     case 77:
 499     case 78:
 500     case 79:
 501     case 80:
 502     case 81:
 503     case 82:
 504     case 83:
 505     case 84:
 506     case 85:
 507     case 86:
 508     case 87:
 509     case 88:
 510     case 89:
 511     case 90:
 512     case 91:
 513     case 92:
 514     case 93:
 515     case 94:
 516     case 95:
 517     case 96:
 518     case 97:
 519     case 98:
 520     case 99:
 521     case 100:
 522     case 101:
 523     case 102:
 524     case 103:
 525     case 104:
 526     case 105:
 527     case 106:
 528     case 107:
 529     case 108:
 530     case 109:
 531     case 110:
 532     case 111:
 533     case 112:
 534     case 113:
 535     case 114:
 536     case 115:
 537     case 116:
 538     case 117:
 539     case 118:
 540     case 119:
 541     case 120:
 542     case 121:
 543     case 122:
 544     case 123:
 545     case 124:
 546     case 125:
 547     case 126:
 548     case 127:
 549     case 128:
 550     case 129:
 551     case 130:
 552     case 131:
 553     case 132:
 554     case 133:
 555     case 134:
 556     case 135:
 557     case 136:
 558     case 137:
 559     case 138:
 560     case 139:
 561     case 140:
 562     case 141:
 563     case 142:
 564     case 143:
 565     case 144:
 566     case 145:
 567     case 146:
 568     case 147:
 569     case 148:
 570     case 149:
 571     case 150:
 572     case 151:
 573     case 152:
 574     case 153:
 575     case 154:
 576     case 155:
 577     case 156:
 578     case 157:
 579     case 158:
 580     case 159:
 581     case 160:
 582     case 161:
 583     case 162:
 584     case 163:
 585     case 164:
 586     case 165:
 587     case 166:
 588     case 167:
 589     case 168:
 590     case 169:
 591     case 170:
 592     case 171:
 593     case 172:
 594     case 173:
 595     case 174:
 596     case 175:
 597     case 176:
 598     case 177:
 599     case 178:
 600     case 179:
 601     case 180:
 602     case 181:
 603     case 182:
 604     case 183:
 605     case 184:
 606     case 185:
 607     case 186:
 608     case 187:
 609     case 188:
 610     case 189:
 611     case 190:
 612     case 191:
 613     case 192:
 614     case 193:
 615     case 194:
 616     case 195:
 617     case 196:
 618     case 197:
 619     case 198:
 620     case 199:
 621     case 200:
 622     case 201:
 623     case 202:
 624     case 203:
 625     case 204:
 626     case 205:
 627     case 206:
 628     case 207:
 629     case 208:
 630     case 209:
 631     case 210:
 632     case 211:
 633     case 212:
 634     case 213:
 635     case 214:
 636     case 215:
 637     case 216:
 638     case 217:
 639     case 218:
 640     case 219:
 641     case 220:
 642     case 221:
 643     case 222:
 644     case 223:
 645     case 224:
 646     case 225:
 647     case 226:
 648     case 227:
 649     case 228:
 650     case 229:
 651     case 230:
 652     case 231:
 653     case 232:
 654     case 233:
 655     case 234:
 656     case 235:
 657     case 236:
 658     case 237:
 659     case 238:
 660     case 239:
 661     case 240:
 662     case 241:
 663     case 242:
 664     case 243:
 665     case 244:
 666     case 245:
 667     case 246:
 668     case 247:
 669     case 248:
 670     case 249:
 671     case 250:
 672     case 251:
 673     case 252:
 674     case 253:
 675     case 254:
 676     case 255:
 677       if (NULL == obj->socks4a_addr_hostname)
 678         return "Missing socks4a_addr_hostname";
 679       break;
 680
 681     default:
 682       break;
 683   }
 684   return NULL;
 685 }
 686
 687 ssize_t
 688 socks4_client_request_encoded_len(const socks4_client_request_t *obj)
 689 {
 690   ssize_t result = 0;
 691
 692   if (NULL != socks4_client_request_check(obj))
 693      return -1;
 694
 695
 696   /* Length of u8 version IN [4] */
 697   result += 1;
 698
 699   /* Length of u8 command IN [CMD_BIND, CMD_CONNECT, CMD_RESOLVE, CMD_RESOLVE_PTR] */
 700   result += 1;
 701
 702   /* Length of u16 port */
 703   result += 2;
 704
 705   /* Length of u32 addr */
 706   result += 4;
 707
 708   /* Length of nulterm username */
 709   result += strlen(obj->username) + 1;
 710   switch (obj->addr) {
 711
 712     case 1:
 713     case 2:
 714     case 3:
 715     case 4:
 716     case 5:
 717     case 6:
 718     case 7:
 719     case 8:
 720     case 9:
 721     case 10:
 722     case 11:
 723     case 12:
 724     case 13:
 725     case 14:
 726     case 15:
 727     case 16:
 728     case 17:
 729     case 18:
 730     case 19:
 731     case 20:
 732     case 21:
 733     case 22:
 734     case 23:
 735     case 24:
 736     case 25:
 737     case 26:
 738     case 27:
 739     case 28:
 740     case 29:
 741     case 30:
 742     case 31:
 743     case 32:
 744     case 33:
 745     case 34:
 746     case 35:
 747     case 36:
 748     case 37:
 749     case 38:
 750     case 39:
 751     case 40:
 752     case 41:
 753     case 42:
 754     case 43:
 755     case 44:
 756     case 45:
 757     case 46:
 758     case 47:
 759     case 48:
 760     case 49:
 761     case 50:
 762     case 51:
 763     case 52:
 764     case 53:
 765     case 54:
 766     case 55:
 767     case 56:
 768     case 57:
 769     case 58:
 770     case 59:
 771     case 60:
 772     case 61:
 773     case 62:
 774     case 63:
 775     case 64:
 776     case 65:
 777     case 66:
 778     case 67:
 779     case 68:
 780     case 69:
 781     case 70:
 782     case 71:
 783     case 72:
 784     case 73:
 785     case 74:
 786     case 75:
 787     case 76:
 788     case 77:
 789     case 78:
 790     case 79:
 791     case 80:
 792     case 81:
 793     case 82:
 794     case 83:
 795     case 84:
 796     case 85:
 797     case 86:
 798     case 87:
 799     case 88:
 800     case 89:
 801     case 90:
 802     case 91:
 803     case 92:
 804     case 93:
 805     case 94:
 806     case 95:
 807     case 96:
 808     case 97:
 809     case 98:
 810     case 99:
 811     case 100:
 812     case 101:
 813     case 102:
 814     case 103:
 815     case 104:
 816     case 105:
 817     case 106:
 818     case 107:
 819     case 108:
 820     case 109:
 821     case 110:
 822     case 111:
 823     case 112:
 824     case 113:
 825     case 114:
 826     case 115:
 827     case 116:
 828     case 117:
 829     case 118:
 830     case 119:
 831     case 120:
 832     case 121:
 833     case 122:
 834     case 123:
 835     case 124:
 836     case 125:
 837     case 126:
 838     case 127:
 839     case 128:
 840     case 129:
 841     case 130:
 842     case 131:
 843     case 132:
 844     case 133:
 845     case 134:
 846     case 135:
 847     case 136:
 848     case 137:
 849     case 138:
 850     case 139:
 851     case 140:
 852     case 141:
 853     case 142:
 854     case 143:
 855     case 144:
 856     case 145:
 857     case 146:
 858     case 147:
 859     case 148:
 860     case 149:
 861     case 150:
 862     case 151:
 863     case 152:
 864     case 153:
 865     case 154:
 866     case 155:
 867     case 156:
 868     case 157:
 869     case 158:
 870     case 159:
 871     case 160:
 872     case 161:
 873     case 162:
 874     case 163:
 875     case 164:
 876     case 165:
 877     case 166:
 878     case 167:
 879     case 168:
 880     case 169:
 881     case 170:
 882     case 171:
 883     case 172:
 884     case 173:
 885     case 174:
 886     case 175:
 887     case 176:
 888     case 177:
 889     case 178:
 890     case 179:
 891     case 180:
 892     case 181:
 893     case 182:
 894     case 183:
 895     case 184:
 896     case 185:
 897     case 186:
 898     case 187:
 899     case 188:
 900     case 189:
 901     case 190:
 902     case 191:
 903     case 192:
 904     case 193:
 905     case 194:
 906     case 195:
 907     case 196:
 908     case 197:
 909     case 198:
 910     case 199:
 911     case 200:
 912     case 201:
 913     case 202:
 914     case 203:
 915     case 204:
 916     case 205:
 917     case 206:
 918     case 207:
 919     case 208:
 920     case 209:
 921     case 210:
 922     case 211:
 923     case 212:
 924     case 213:
 925     case 214:
 926     case 215:
 927     case 216:
 928     case 217:
 929     case 218:
 930     case 219:
 931     case 220:
 932     case 221:
 933     case 222:
 934     case 223:
 935     case 224:
 936     case 225:
 937     case 226:
 938     case 227:
 939     case 228:
 940     case 229:
 941     case 230:
 942     case 231:
 943     case 232:
 944     case 233:
 945     case 234:
 946     case 235:
 947     case 236:
 948     case 237:
 949     case 238:
 950     case 239:
 951     case 240:
 952     case 241:
 953     case 242:
 954     case 243:
 955     case 244:
 956     case 245:
 957     case 246:
 958     case 247:
 959     case 248:
 960     case 249:
 961     case 250:
 962     case 251:
 963     case 252:
 964     case 253:
 965     case 254:
 966     case 255:
 967
 968       /* Length of nulterm socks4a_addr_hostname */
 969       result += strlen(obj->socks4a_addr_hostname) + 1;
 970       break;
 971
 972     default:
 973       break;
 974   }
 975   return result;
 976 }
 977 int
 978 socks4_client_request_clear_errors(socks4_client_request_t *obj)
 979 {
 980   int r = obj->trunnel_error_code_;
 981   obj->trunnel_error_code_ = 0;
 982   return r;
 983 }
 984 ssize_t
 985 socks4_client_request_encode(uint8_t *output, const size_t avail, const socks4_client_request_t *obj)
 986 {
 987   ssize_t result = 0;
 988   size_t written = 0;
 989   uint8_t *ptr = output;
 990   const char *msg;
 991 #ifdef TRUNNEL_CHECK_ENCODED_LEN
 992   const ssize_t encoded_len = socks4_client_request_encoded_len(obj);
 993 #endif
 994
 995   if (NULL != (msg = socks4_client_request_check(obj)))
 996     goto check_failed;
 997
 998 #ifdef TRUNNEL_CHECK_ENCODED_LEN
 999   trunnel_assert(encoded_len >= 0);
1000 #endif
1001
1002   /* Encode u8 version IN [4] */
1003   trunnel_assert(written <= avail);
1004   if (avail - written < 1)
1005     goto truncated;
1006   trunnel_set_uint8(ptr, (obj->version));
1007   written += 1; ptr += 1;
1008
1009   /* Encode u8 command IN [CMD_BIND, CMD_CONNECT, CMD_RESOLVE, CMD_RESOLVE_PTR] */
1010   trunnel_assert(written <= avail);
1011   if (avail - written < 1)
1012     goto truncated;
1013   trunnel_set_uint8(ptr, (obj->command));
1014   written += 1; ptr += 1;
1015
1016   /* Encode u16 port */
1017   trunnel_assert(written <= avail);
1018   if (avail - written < 2)
1019     goto truncated;
1020   trunnel_set_uint16(ptr, trunnel_htons(obj->port));
1021   written += 2; ptr += 2;
1022
1023   /* Encode u32 addr */
1024   trunnel_assert(written <= avail);
1025   if (avail - written < 4)
1026     goto truncated;
1027   trunnel_set_uint32(ptr, trunnel_htonl(obj->addr));
1028   written += 4; ptr += 4;
1029
1030   /* Encode nulterm username */
1031   {
1032     size_t len = strlen(obj->username);
1033     trunnel_assert(written <= avail);
1034     if (avail - written < len + 1)
1035       goto truncated;
1036     memcpy(ptr, obj->username, len + 1);
1037     ptr += len + 1; written += len + 1;
1038   }
1039
1040   /* Encode union socks4a_addr[addr] */
1041   trunnel_assert(written <= avail);
1042   switch (obj->addr) {
1043
1044     case 1:
1045     case 2:
1046     case 3:
1047     case 4:
1048     case 5:
1049     case 6:
1050     case 7:
1051     case 8:
1052     case 9:
1053     case 10:
1054     case 11:
1055     case 12:
1056     case 13:
1057     case 14:
1058     case 15:
1059     case 16:
1060     case 17:
1061     case 18:
1062     case 19:
1063     case 20:
1064     case 21:
1065     case 22:
1066     case 23:
1067     case 24:
1068     case 25:
1069     case 26:
1070     case 27:
1071     case 28:
1072     case 29:
1073     case 30:
1074     case 31:
1075     case 32:
1076     case 33:
1077     case 34:
1078     case 35:
1079     case 36:
1080     case 37:
1081     case 38:
1082     case 39:
1083     case 40:
1084     case 41:
1085     case 42:
1086     case 43:
1087     case 44:
1088     case 45:
1089     case 46:
1090     case 47:
1091     case 48:
1092     case 49:
1093     case 50:
1094     case 51:
1095     case 52:
1096     case 53:
1097     case 54:
1098     case 55:
1099     case 56:
1100     case 57:
1101     case 58:
1102     case 59:
1103     case 60:
1104     case 61:
1105     case 62:
1106     case 63:
1107     case 64:
1108     case 65:
1109     case 66:
1110     case 67:
1111     case 68:
1112     case 69:
1113     case 70:
1114     case 71:
1115     case 72:
1116     case 73:
1117     case 74:
1118     case 75:
1119     case 76:
1120     case 77:
1121     case 78:
1122     case 79:
1123     case 80:
1124     case 81:
1125     case 82:
1126     case 83:
1127     case 84:
1128     case 85:
1129     case 86:
1130     case 87:
1131     case 88:
1132     case 89:
1133     case 90:
1134     case 91:
1135     case 92:
1136     case 93:
1137     case 94:
1138     case 95:
1139     case 96:
1140     case 97:
1141     case 98:
1142     case 99:
1143     case 100:
1144     case 101:
1145     case 102:
1146     case 103:
1147     case 104:
1148     case 105:
1149     case 106:
1150     case 107:
1151     case 108:
1152     case 109:
1153     case 110:
1154     case 111:
1155     case 112:
1156     case 113:
1157     case 114:
1158     case 115:
1159     case 116:
1160     case 117:
1161     case 118:
1162     case 119:
1163     case 120:
1164     case 121:
1165     case 122:
1166     case 123:
1167     case 124:
1168     case 125:
1169     case 126:
1170     case 127:
1171     case 128:
1172     case 129:
1173     case 130:
1174     case 131:
1175     case 132:
1176     case 133:
1177     case 134:
1178     case 135:
1179     case 136:
1180     case 137:
1181     case 138:
1182     case 139:
1183     case 140:
1184     case 141:
1185     case 142:
1186     case 143:
1187     case 144:
1188     case 145:
1189     case 146:
1190     case 147:
1191     case 148:
1192     case 149:
1193     case 150:
1194     case 151:
1195     case 152:
1196     case 153:
1197     case 154:
1198     case 155:
1199     case 156:
1200     case 157:
1201     case 158:
1202     case 159:
1203     case 160:
1204     case 161:
1205     case 162:
1206     case 163:
1207     case 164:
1208     case 165:
1209     case 166:
1210     case 167:
1211     case 168:
1212     case 169:
1213     case 170:
1214     case 171:
1215     case 172:
1216     case 173:
1217     case 174:
1218     case 175:
1219     case 176:
1220     case 177:
1221     case 178:
1222     case 179:
1223     case 180:
1224     case 181:
1225     case 182:
1226     case 183:
1227     case 184:
1228     case 185:
1229     case 186:
1230     case 187:
1231     case 188:
1232     case 189:
1233     case 190:
1234     case 191:
1235     case 192:
1236     case 193:
1237     case 194:
1238     case 195:
1239     case 196:
1240     case 197:
1241     case 198:
1242     case 199:
1243     case 200:
1244     case 201:
1245     case 202:
1246     case 203:
1247     case 204:
1248     case 205:
1249     case 206:
1250     case 207:
1251     case 208:
1252     case 209:
1253     case 210:
1254     case 211:
1255     case 212:
1256     case 213:
1257     case 214:
1258     case 215:
1259     case 216:
1260     case 217:
1261     case 218:
1262     case 219:
1263     case 220:
1264     case 221:
1265     case 222:
1266     case 223:
1267     case 224:
1268     case 225:
1269     case 226:
1270     case 227:
1271     case 228:
1272     case 229:
1273     case 230:
1274     case 231:
1275     case 232:
1276     case 233:
1277     case 234:
1278     case 235:
1279     case 236:
1280     case 237:
1281     case 238:
1282     case 239:
1283     case 240:
1284     case 241:
1285     case 242:
1286     case 243:
1287     case 244:
1288     case 245:
1289     case 246:
1290     case 247:
1291     case 248:
1292     case 249:
1293     case 250:
1294     case 251:
1295     case 252:
1296     case 253:
1297     case 254:
1298     case 255:
1299
1300       /* Encode nulterm socks4a_addr_hostname */
1301       {
1302         size_t len = strlen(obj->socks4a_addr_hostname);
1303         trunnel_assert(written <= avail);
1304         if (avail - written < len + 1)
1305           goto truncated;
1306         memcpy(ptr, obj->socks4a_addr_hostname, len + 1);
1307         ptr += len + 1; written += len + 1;
1308       }
1309       break;
1310
1311     default:
1312       break;
1313   }
1314
1315
1316   trunnel_assert(ptr == output + written);
1317 #ifdef TRUNNEL_CHECK_ENCODED_LEN
1318   {
1319     trunnel_assert(encoded_len >= 0);
1320     trunnel_assert((size_t)encoded_len == written);
1321   }
1322
1323 #endif
1324
1325   return written;
1326
1327  truncated:
1328   result = -2;
1329   goto fail;
1330  check_failed:
1331   (void)msg;
1332   result = -1;
1333   goto fail;
1334  fail:
1335   trunnel_assert(result < 0);
1336   return result;
1337 }
1338
1339 /** As socks4_client_request_parse(), but do not allocate the output
1340  * object.
1341  */
1342 static ssize_t
1343 socks4_client_request_parse_into(socks4_client_request_t *obj, const uint8_t *input, const size_t len_in)
1344 {
1345   const uint8_t *ptr = input;
1346   size_t remaining = len_in;
1347   ssize_t result = 0;
1348   (void)result;
1349
1350   /* Parse u8 version IN [4] */
1351   CHECK_REMAINING(1, truncated);
1352   obj->version = (trunnel_get_uint8(ptr));
1353   remaining -= 1; ptr += 1;
1354   if (! (obj->version == 4))
1355     goto fail;
1356
1357   /* Parse u8 command IN [CMD_BIND, CMD_CONNECT, CMD_RESOLVE, CMD_RESOLVE_PTR] */
1358   CHECK_REMAINING(1, truncated);
1359   obj->command = (trunnel_get_uint8(ptr));
1360   remaining -= 1; ptr += 1;
1361   if (! (obj->command == CMD_BIND || obj->command == CMD_CONNECT || obj->command == CMD_RESOLVE || obj->command == CMD_RESOLVE_PTR))
1362     goto fail;
1363
1364   /* Parse u16 port */
1365   CHECK_REMAINING(2, truncated);
1366   obj->port = trunnel_ntohs(trunnel_get_uint16(ptr));
1367   remaining -= 2; ptr += 2;
1368
1369   /* Parse u32 addr */
1370   CHECK_REMAINING(4, truncated);
1371   obj->addr = trunnel_ntohl(trunnel_get_uint32(ptr));
1372   remaining -= 4; ptr += 4;
1373
1374   /* Parse nulterm username */
1375   {
1376     uint8_t *eos = (uint8_t*)memchr(ptr, 0, remaining);
1377     size_t memlen;
1378     if (eos == NULL)
1379       goto truncated;
1380     trunnel_assert(eos >= ptr);
1381     trunnel_assert((size_t)(eos - ptr) < SIZE_MAX - 1);
1382     memlen = ((size_t)(eos - ptr)) + 1;
1383     if (!(obj->username = trunnel_malloc(memlen)))
1384       goto fail;
1385     memcpy(obj->username, ptr, memlen);
1386     remaining -= memlen; ptr += memlen;
1387   }
1388
1389   /* Parse union socks4a_addr[addr] */
1390   switch (obj->addr) {
1391
1392     case 1:
1393     case 2:
1394     case 3:
1395     case 4:
1396     case 5:
1397     case 6:
1398     case 7:
1399     case 8:
1400     case 9:
1401     case 10:
1402     case 11:
1403     case 12:
1404     case 13:
1405     case 14:
1406     case 15:
1407     case 16:
1408     case 17:
1409     case 18:
1410     case 19:
1411     case 20:
1412     case 21:
1413     case 22:
1414     case 23:
1415     case 24:
1416     case 25:
1417     case 26:
1418     case 27:
1419     case 28:
1420     case 29:
1421     case 30:
1422     case 31:
1423     case 32:
1424     case 33:
1425     case 34:
1426     case 35:
1427     case 36:
1428     case 37:
1429     case 38:
1430     case 39:
1431     case 40:
1432     case 41:
1433     case 42:
1434     case 43:
1435     case 44:
1436     case 45:
1437     case 46:
1438     case 47:
1439     case 48:
1440     case 49:
1441     case 50:
1442     case 51:
1443     case 52:
1444     case 53:
1445     case 54:
1446     case 55:
1447     case 56:
1448     case 57:
1449     case 58:
1450     case 59:
1451     case 60:
1452     case 61:
1453     case 62:
1454     case 63:
1455     case 64:
1456     case 65:
1457     case 66:
1458     case 67:
1459     case 68:
1460     case 69:
1461     case 70:
1462     case 71:
1463     case 72:
1464     case 73:
1465     case 74:
1466     case 75:
1467     case 76:
1468     case 77:
1469     case 78:
1470     case 79:
1471     case 80:
1472     case 81:
1473     case 82:
1474     case 83:
1475     case 84:
1476     case 85:
1477     case 86:
1478     case 87:
1479     case 88:
1480     case 89:
1481     case 90:
1482     case 91:
1483     case 92:
1484     case 93:
1485     case 94:
1486     case 95:
1487     case 96:
1488     case 97:
1489     case 98:
1490     case 99:
1491     case 100:
1492     case 101:
1493     case 102:
1494     case 103:
1495     case 104:
1496     case 105:
1497     case 106:
1498     case 107:
1499     case 108:
1500     case 109:
1501     case 110:
1502     case 111:
1503     case 112:
1504     case 113:
1505     case 114:
1506     case 115:
1507     case 116:
1508     case 117:
1509     case 118:
1510     case 119:
1511     case 120:
1512     case 121:
1513     case 122:
1514     case 123:
1515     case 124:
1516     case 125:
1517     case 126:
1518     case 127:
1519     case 128:
1520     case 129:
1521     case 130:
1522     case 131:
1523     case 132:
1524     case 133:
1525     case 134:
1526     case 135:
1527     case 136:
1528     case 137:
1529     case 138:
1530     case 139:
1531     case 140:
1532     case 141:
1533     case 142:
1534     case 143:
1535     case 144:
1536     case 145:
1537     case 146:
1538     case 147:
1539     case 148:
1540     case 149:
1541     case 150:
1542     case 151:
1543     case 152:
1544     case 153:
1545     case 154:
1546     case 155:
1547     case 156:
1548     case 157:
1549     case 158:
1550     case 159:
1551     case 160:
1552     case 161:
1553     case 162:
1554     case 163:
1555     case 164:
1556     case 165:
1557     case 166:
1558     case 167:
1559     case 168:
1560     case 169:
1561     case 170:
1562     case 171:
1563     case 172:
1564     case 173:
1565     case 174:
1566     case 175:
1567     case 176:
1568     case 177:
1569     case 178:
1570     case 179:
1571     case 180:
1572     case 181:
1573     case 182:
1574     case 183:
1575     case 184:
1576     case 185:
1577     case 186:
1578     case 187:
1579     case 188:
1580     case 189:
1581     case 190:
1582     case 191:
1583     case 192:
1584     case 193:
1585     case 194:
1586     case 195:
1587     case 196:
1588     case 197:
1589     case 198:
1590     case 199:
1591     case 200:
1592     case 201:
1593     case 202:
1594     case 203:
1595     case 204:
1596     case 205:
1597     case 206:
1598     case 207:
1599     case 208:
1600     case 209:
1601     case 210:
1602     case 211:
1603     case 212:
1604     case 213:
1605     case 214:
1606     case 215:
1607     case 216:
1608     case 217:
1609     case 218:
1610     case 219:
1611     case 220:
1612     case 221:
1613     case 222:
1614     case 223:
1615     case 224:
1616     case 225:
1617     case 226:
1618     case 227:
1619     case 228:
1620     case 229:
1621     case 230:
1622     case 231:
1623     case 232:
1624     case 233:
1625     case 234:
1626     case 235:
1627     case 236:
1628     case 237:
1629     case 238:
1630     case 239:
1631     case 240:
1632     case 241:
1633     case 242:
1634     case 243:
1635     case 244:
1636     case 245:
1637     case 246:
1638     case 247:
1639     case 248:
1640     case 249:
1641     case 250:
1642     case 251:
1643     case 252:
1644     case 253:
1645     case 254:
1646     case 255:
1647
1648       /* Parse nulterm socks4a_addr_hostname */
1649       {
1650         uint8_t *eos = (uint8_t*)memchr(ptr, 0, remaining);
1651         size_t memlen;
1652         if (eos == NULL)
1653           goto truncated;
1654         trunnel_assert(eos >= ptr);
1655         trunnel_assert((size_t)(eos - ptr) < SIZE_MAX - 1);
1656         memlen = ((size_t)(eos - ptr)) + 1;
1657         if (!(obj->socks4a_addr_hostname = trunnel_malloc(memlen)))
1658           goto fail;
1659         memcpy(obj->socks4a_addr_hostname, ptr, memlen);
1660         remaining -= memlen; ptr += memlen;
1661       }
1662       break;
1663
1664     default:
1665       break;
1666   }
1667   trunnel_assert(ptr + remaining == input + len_in);
1668   return len_in - remaining;
1669
1670  truncated:
1671   return -2;
1672  fail:
1673   result = -1;
1674   return result;
1675 }
1676
1677 ssize_t
1678 socks4_client_request_parse(socks4_client_request_t **output, const uint8_t *input, const size_t len_in)
1679 {
1680   ssize_t result;
1681   *output = socks4_client_request_new();
1682   if (NULL == *output)
1683     return -1;
1684   result = socks4_client_request_parse_into(*output, input, len_in);
1685   if (result < 0) {
1686     socks4_client_request_free(*output);
1687     *output = NULL;
1688   }
1689   return result;
1690 }
1691 socks4_server_reply_t *
1692 socks4_server_reply_new(void)
1693 {
1694   socks4_server_reply_t *val = trunnel_calloc(1, sizeof(socks4_server_reply_t));
1695   if (NULL == val)
1696     return NULL;
1697   return val;
1698 }
1699
1700 /** Release all storage held inside 'obj', but do not free 'obj'.
1701  */
1702 static void
1703 socks4_server_reply_clear(socks4_server_reply_t *obj)
1704 {
1705   (void) obj;
1706 }
1707
1708 void
1709 socks4_server_reply_free(socks4_server_reply_t *obj)
1710 {
1711   if (obj == NULL)
1712     return;
1713   socks4_server_reply_clear(obj);
1714   trunnel_memwipe(obj, sizeof(socks4_server_reply_t));
1715   trunnel_free_(obj);
1716 }
1717
1718 uint8_t
1719 socks4_server_reply_get_version(const socks4_server_reply_t *inp)
1720 {
1721   return inp->version;
1722 }
1723 int
1724 socks4_server_reply_set_version(socks4_server_reply_t *inp, uint8_t val)
1725 {
1726   if (! ((val == 0 || val == 4))) {
1727      TRUNNEL_SET_ERROR_CODE(inp);
1728      return -1;
1729   }
1730   inp->version = val;
1731   return 0;
1732 }
1733 uint8_t
1734 socks4_server_reply_get_status(const socks4_server_reply_t *inp)
1735 {
1736   return inp->status;
1737 }
1738 int
1739 socks4_server_reply_set_status(socks4_server_reply_t *inp, uint8_t val)
1740 {
1741   inp->status = val;
1742   return 0;
1743 }
1744 uint16_t
1745 socks4_server_reply_get_port(const socks4_server_reply_t *inp)
1746 {
1747   return inp->port;
1748 }
1749 int
1750 socks4_server_reply_set_port(socks4_server_reply_t *inp, uint16_t val)
1751 {
1752   inp->port = val;
1753   return 0;
1754 }
1755 uint32_t
1756 socks4_server_reply_get_addr(const socks4_server_reply_t *inp)
1757 {
1758   return inp->addr;
1759 }
1760 int
1761 socks4_server_reply_set_addr(socks4_server_reply_t *inp, uint32_t val)
1762 {
1763   inp->addr = val;
1764   return 0;
1765 }
1766 const char *
1767 socks4_server_reply_check(const socks4_server_reply_t *obj)
1768 {
1769   if (obj == NULL)
1770     return "Object was NULL";
1771   if (obj->trunnel_error_code_)
1772     return "A set function failed on this object";
1773   if (! (obj->version == 0 || obj->version == 4))
1774     return "Integer out of bounds";
1775   return NULL;
1776 }
1777
1778 ssize_t
1779 socks4_server_reply_encoded_len(const socks4_server_reply_t *obj)
1780 {
1781   ssize_t result = 0;
1782
1783   if (NULL != socks4_server_reply_check(obj))
1784      return -1;
1785
1786
1787   /* Length of u8 version IN [0, 4] */
1788   result += 1;
1789
1790   /* Length of u8 status */
1791   result += 1;
1792
1793   /* Length of u16 port */
1794   result += 2;
1795
1796   /* Length of u32 addr */
1797   result += 4;
1798   return result;
1799 }
1800 int
1801 socks4_server_reply_clear_errors(socks4_server_reply_t *obj)
1802 {
1803   int r = obj->trunnel_error_code_;
1804   obj->trunnel_error_code_ = 0;
1805   return r;
1806 }
1807 ssize_t
1808 socks4_server_reply_encode(uint8_t *output, const size_t avail, const socks4_server_reply_t *obj)
1809 {
1810   ssize_t result = 0;
1811   size_t written = 0;
1812   uint8_t *ptr = output;
1813   const char *msg;
1814 #ifdef TRUNNEL_CHECK_ENCODED_LEN
1815   const ssize_t encoded_len = socks4_server_reply_encoded_len(obj);
1816 #endif
1817
1818   if (NULL != (msg = socks4_server_reply_check(obj)))
1819     goto check_failed;
1820
1821 #ifdef TRUNNEL_CHECK_ENCODED_LEN
1822   trunnel_assert(encoded_len >= 0);
1823 #endif
1824
1825   /* Encode u8 version IN [0, 4] */
1826   trunnel_assert(written <= avail);
1827   if (avail - written < 1)
1828     goto truncated;
1829   trunnel_set_uint8(ptr, (obj->version));
1830   written += 1; ptr += 1;
1831
1832   /* Encode u8 status */
1833   trunnel_assert(written <= avail);
1834   if (avail - written < 1)
1835     goto truncated;
1836   trunnel_set_uint8(ptr, (obj->status));
1837   written += 1; ptr += 1;
1838
1839   /* Encode u16 port */
1840   trunnel_assert(written <= avail);
1841   if (avail - written < 2)
1842     goto truncated;
1843   trunnel_set_uint16(ptr, trunnel_htons(obj->port));
1844   written += 2; ptr += 2;
1845
1846   /* Encode u32 addr */
1847   trunnel_assert(written <= avail);
1848   if (avail - written < 4)
1849     goto truncated;
1850   trunnel_set_uint32(ptr, trunnel_htonl(obj->addr));
1851   written += 4; ptr += 4;
1852
1853
1854   trunnel_assert(ptr == output + written);
1855 #ifdef TRUNNEL_CHECK_ENCODED_LEN
1856   {
1857     trunnel_assert(encoded_len >= 0);
1858     trunnel_assert((size_t)encoded_len == written);
1859   }
1860
1861 #endif
1862
1863   return written;
1864
1865  truncated:
1866   result = -2;
1867   goto fail;
1868  check_failed:
1869   (void)msg;
1870   result = -1;
1871   goto fail;
1872  fail:
1873   trunnel_assert(result < 0);
1874   return result;
1875 }
1876
1877 /** As socks4_server_reply_parse(), but do not allocate the output
1878  * object.
1879  */
1880 static ssize_t
1881 socks4_server_reply_parse_into(socks4_server_reply_t *obj, const uint8_t *input, const size_t len_in)
1882 {
1883   const uint8_t *ptr = input;
1884   size_t remaining = len_in;
1885   ssize_t result = 0;
1886   (void)result;
1887
1888   /* Parse u8 version IN [0, 4] */
1889   CHECK_REMAINING(1, truncated);
1890   obj->version = (trunnel_get_uint8(ptr));
1891   remaining -= 1; ptr += 1;
1892   if (! (obj->version == 0 || obj->version == 4))
1893     goto fail;
1894
1895   /* Parse u8 status */
1896   CHECK_REMAINING(1, truncated);
1897   obj->status = (trunnel_get_uint8(ptr));
1898   remaining -= 1; ptr += 1;
1899
1900   /* Parse u16 port */
1901   CHECK_REMAINING(2, truncated);
1902   obj->port = trunnel_ntohs(trunnel_get_uint16(ptr));
1903   remaining -= 2; ptr += 2;
1904
1905   /* Parse u32 addr */
1906   CHECK_REMAINING(4, truncated);
1907   obj->addr = trunnel_ntohl(trunnel_get_uint32(ptr));
1908   remaining -= 4; ptr += 4;
1909   trunnel_assert(ptr + remaining == input + len_in);
1910   return len_in - remaining;
1911
1912  truncated:
1913   return -2;
1914  fail:
1915   result = -1;
1916   return result;
1917 }
1918
1919 ssize_t
1920 socks4_server_reply_parse(socks4_server_reply_t **output, const uint8_t *input, const size_t len_in)
1921 {
1922   ssize_t result;
1923   *output = socks4_server_reply_new();
1924   if (NULL == *output)
1925     return -1;
1926   result = socks4_server_reply_parse_into(*output, input, len_in);
1927   if (result < 0) {
1928     socks4_server_reply_free(*output);
1929     *output = NULL;
1930   }
1931   return result;
1932 }
1933 socks5_client_userpass_auth_t *
1934 socks5_client_userpass_auth_new(void)
1935 {
1936   socks5_client_userpass_auth_t *val = trunnel_calloc(1, sizeof(socks5_client_userpass_auth_t));
1937   if (NULL == val)
1938     return NULL;
1939   val->version = 1;
1940   return val;
1941 }
1942
1943 /** Release all storage held inside 'obj', but do not free 'obj'.
1944  */
1945 static void
1946 socks5_client_userpass_auth_clear(socks5_client_userpass_auth_t *obj)
1947 {
1948   (void) obj;
1949   TRUNNEL_DYNARRAY_WIPE(&obj->username);
1950   TRUNNEL_DYNARRAY_CLEAR(&obj->username);
1951   TRUNNEL_DYNARRAY_WIPE(&obj->passwd);
1952   TRUNNEL_DYNARRAY_CLEAR(&obj->passwd);
1953 }
1954
1955 void
1956 socks5_client_userpass_auth_free(socks5_client_userpass_auth_t *obj)
1957 {
1958   if (obj == NULL)
1959     return;
1960   socks5_client_userpass_auth_clear(obj);
1961   trunnel_memwipe(obj, sizeof(socks5_client_userpass_auth_t));
1962   trunnel_free_(obj);
1963 }
1964
1965 uint8_t
1966 socks5_client_userpass_auth_get_version(const socks5_client_userpass_auth_t *inp)
1967 {
1968   return inp->version;
1969 }
1970 int
1971 socks5_client_userpass_auth_set_version(socks5_client_userpass_auth_t *inp, uint8_t val)
1972 {
1973   if (! ((val == 1))) {
1974      TRUNNEL_SET_ERROR_CODE(inp);
1975      return -1;
1976   }
1977   inp->version = val;
1978   return 0;
1979 }
1980 uint8_t
1981 socks5_client_userpass_auth_get_username_len(const socks5_client_userpass_auth_t *inp)
1982 {
1983   return inp->username_len;
1984 }
1985 int
1986 socks5_client_userpass_auth_set_username_len(socks5_client_userpass_auth_t *inp, uint8_t val)
1987 {
1988   inp->username_len = val;
1989   return 0;
1990 }
1991 size_t
1992 socks5_client_userpass_auth_getlen_username(const socks5_client_userpass_auth_t *inp)
1993 {
1994   return TRUNNEL_DYNARRAY_LEN(&inp->username);
1995 }
1996
1997 char
1998 socks5_client_userpass_auth_get_username(socks5_client_userpass_auth_t *inp, size_t idx)
1999 {
2000   return TRUNNEL_DYNARRAY_GET(&inp->username, idx);
2001 }
2002
2003 char
2004 socks5_client_userpass_auth_getconst_username(const socks5_client_userpass_auth_t *inp, size_t idx)
2005 {
2006   return socks5_client_userpass_auth_get_username((socks5_client_userpass_auth_t*)inp, idx);
2007 }
2008 int
2009 socks5_client_userpass_auth_set_username(socks5_client_userpass_auth_t *inp, size_t idx, char elt)
2010 {
2011   TRUNNEL_DYNARRAY_SET(&inp->username, idx, elt);
2012   return 0;
2013 }
2014 int
2015 socks5_client_userpass_auth_add_username(socks5_client_userpass_auth_t *inp, char elt)
2016 {
2017 #if SIZE_MAX >= UINT8_MAX
2018   if (inp->username.n_ == UINT8_MAX)
2019     goto trunnel_alloc_failed;
2020 #endif
2021   TRUNNEL_DYNARRAY_ADD(char, &inp->username, elt, {});
2022   return 0;
2023  trunnel_alloc_failed:
2024   TRUNNEL_SET_ERROR_CODE(inp);
2025   return -1;
2026 }
2027
2028 char *
2029 socks5_client_userpass_auth_getarray_username(socks5_client_userpass_auth_t *inp)
2030 {
2031   return inp->username.elts_;
2032 }
2033 const char  *
2034 socks5_client_userpass_auth_getconstarray_username(const socks5_client_userpass_auth_t *inp)
2035 {
2036   return (const char  *)socks5_client_userpass_auth_getarray_username((socks5_client_userpass_auth_t*)inp);
2037 }
2038 int
2039 socks5_client_userpass_auth_setlen_username(socks5_client_userpass_auth_t *inp, size_t newlen)
2040 {
2041 #if UINT8_MAX < SIZE_MAX
2042   if (newlen > UINT8_MAX)
2043     goto trunnel_alloc_failed;
2044 #endif
2045   return trunnel_string_setlen(&inp->username, newlen,
2046             &inp->trunnel_error_code_);
2047  trunnel_alloc_failed:
2048   TRUNNEL_SET_ERROR_CODE(inp);
2049   return -1;
2050 }
2051 const char *
2052 socks5_client_userpass_auth_getstr_username(socks5_client_userpass_auth_t *inp)
2053 {
2054   return trunnel_string_getstr(&inp->username);
2055 }
2056 int
2057 socks5_client_userpass_auth_setstr0_username(socks5_client_userpass_auth_t *inp, const char *val, size_t len)
2058 {
2059 #if UINT8_MAX < SIZE_MAX
2060   if (len > UINT8_MAX) {
2061     TRUNNEL_SET_ERROR_CODE(inp);
2062     return -1;
2063   }
2064 #endif
2065   return trunnel_string_setstr0(&inp->username, val, len, &inp->trunnel_error_code_);
2066 }
2067 int
2068 socks5_client_userpass_auth_setstr_username(socks5_client_userpass_auth_t *inp, const char *val)
2069 {
2070   return socks5_client_userpass_auth_setstr0_username(inp, val, strlen(val));
2071 }
2072 uint8_t
2073 socks5_client_userpass_auth_get_passwd_len(const socks5_client_userpass_auth_t *inp)
2074 {
2075   return inp->passwd_len;
2076 }
2077 int
2078 socks5_client_userpass_auth_set_passwd_len(socks5_client_userpass_auth_t *inp, uint8_t val)
2079 {
2080   inp->passwd_len = val;
2081   return 0;
2082 }
2083 size_t
2084 socks5_client_userpass_auth_getlen_passwd(const socks5_client_userpass_auth_t *inp)
2085 {
2086   return TRUNNEL_DYNARRAY_LEN(&inp->passwd);
2087 }
2088
2089 char
2090 socks5_client_userpass_auth_get_passwd(socks5_client_userpass_auth_t *inp, size_t idx)
2091 {
2092   return TRUNNEL_DYNARRAY_GET(&inp->passwd, idx);
2093 }
2094
2095 char
2096 socks5_client_userpass_auth_getconst_passwd(const socks5_client_userpass_auth_t *inp, size_t idx)
2097 {
2098   return socks5_client_userpass_auth_get_passwd((socks5_client_userpass_auth_t*)inp, idx);
2099 }
2100 int
2101 socks5_client_userpass_auth_set_passwd(socks5_client_userpass_auth_t *inp, size_t idx, char elt)
2102 {
2103   TRUNNEL_DYNARRAY_SET(&inp->passwd, idx, elt);
2104   return 0;
2105 }
2106 int
2107 socks5_client_userpass_auth_add_passwd(socks5_client_userpass_auth_t *inp, char elt)
2108 {
2109 #if SIZE_MAX >= UINT8_MAX
2110   if (inp->passwd.n_ == UINT8_MAX)
2111     goto trunnel_alloc_failed;
2112 #endif
2113   TRUNNEL_DYNARRAY_ADD(char, &inp->passwd, elt, {});
2114   return 0;
2115  trunnel_alloc_failed:
2116   TRUNNEL_SET_ERROR_CODE(inp);
2117   return -1;
2118 }
2119
2120 char *
2121 socks5_client_userpass_auth_getarray_passwd(socks5_client_userpass_auth_t *inp)
2122 {
2123   return inp->passwd.elts_;
2124 }
2125 const char  *
2126 socks5_client_userpass_auth_getconstarray_passwd(const socks5_client_userpass_auth_t *inp)
2127 {
2128   return (const char  *)socks5_client_userpass_auth_getarray_passwd((socks5_client_userpass_auth_t*)inp);
2129 }
2130 int
2131 socks5_client_userpass_auth_setlen_passwd(socks5_client_userpass_auth_t *inp, size_t newlen)
2132 {
2133 #if UINT8_MAX < SIZE_MAX
2134   if (newlen > UINT8_MAX)
2135     goto trunnel_alloc_failed;
2136 #endif
2137   return trunnel_string_setlen(&inp->passwd, newlen,
2138             &inp->trunnel_error_code_);
2139  trunnel_alloc_failed:
2140   TRUNNEL_SET_ERROR_CODE(inp);
2141   return -1;
2142 }
2143 const char *
2144 socks5_client_userpass_auth_getstr_passwd(socks5_client_userpass_auth_t *inp)
2145 {
2146   return trunnel_string_getstr(&inp->passwd);
2147 }
2148 int
2149 socks5_client_userpass_auth_setstr0_passwd(socks5_client_userpass_auth_t *inp, const char *val, size_t len)
2150 {
2151 #if UINT8_MAX < SIZE_MAX
2152   if (len > UINT8_MAX) {
2153     TRUNNEL_SET_ERROR_CODE(inp);
2154     return -1;
2155   }
2156 #endif
2157   return trunnel_string_setstr0(&inp->passwd, val, len, &inp->trunnel_error_code_);
2158 }
2159 int
2160 socks5_client_userpass_auth_setstr_passwd(socks5_client_userpass_auth_t *inp, const char *val)
2161 {
2162   return socks5_client_userpass_auth_setstr0_passwd(inp, val, strlen(val));
2163 }
2164 const char *
2165 socks5_client_userpass_auth_check(const socks5_client_userpass_auth_t *obj)
2166 {
2167   if (obj == NULL)
2168     return "Object was NULL";
2169   if (obj->trunnel_error_code_)
2170     return "A set function failed on this object";
2171   if (! (obj->version == 1))
2172     return "Integer out of bounds";
2173   if (TRUNNEL_DYNARRAY_LEN(&obj->username) != obj->username_len)
2174     return "Length mismatch for username";
2175   if (TRUNNEL_DYNARRAY_LEN(&obj->passwd) != obj->passwd_len)
2176     return "Length mismatch for passwd";
2177   return NULL;
2178 }
2179
2180 ssize_t
2181 socks5_client_userpass_auth_encoded_len(const socks5_client_userpass_auth_t *obj)
2182 {
2183   ssize_t result = 0;
2184
2185   if (NULL != socks5_client_userpass_auth_check(obj))
2186      return -1;
2187
2188
2189   /* Length of u8 version IN [1] */
2190   result += 1;
2191
2192   /* Length of u8 username_len */
2193   result += 1;
2194
2195   /* Length of char username[username_len] */
2196   result += TRUNNEL_DYNARRAY_LEN(&obj->username);
2197
2198   /* Length of u8 passwd_len */
2199   result += 1;
2200
2201   /* Length of char passwd[passwd_len] */
2202   result += TRUNNEL_DYNARRAY_LEN(&obj->passwd);
2203   return result;
2204 }
2205 int
2206 socks5_client_userpass_auth_clear_errors(socks5_client_userpass_auth_t *obj)
2207 {
2208   int r = obj->trunnel_error_code_;
2209   obj->trunnel_error_code_ = 0;
2210   return r;
2211 }
2212 ssize_t
2213 socks5_client_userpass_auth_encode(uint8_t *output, const size_t avail, const socks5_client_userpass_auth_t *obj)
2214 {
2215   ssize_t result = 0;
2216   size_t written = 0;
2217   uint8_t *ptr = output;
2218   const char *msg;
2219 #ifdef TRUNNEL_CHECK_ENCODED_LEN
2220   const ssize_t encoded_len = socks5_client_userpass_auth_encoded_len(obj);
2221 #endif
2222
2223   if (NULL != (msg = socks5_client_userpass_auth_check(obj)))
2224     goto check_failed;
2225
2226 #ifdef TRUNNEL_CHECK_ENCODED_LEN
2227   trunnel_assert(encoded_len >= 0);
2228 #endif
2229
2230   /* Encode u8 version IN [1] */
2231   trunnel_assert(written <= avail);
2232   if (avail - written < 1)
2233     goto truncated;
2234   trunnel_set_uint8(ptr, (obj->version));
2235   written += 1; ptr += 1;
2236
2237   /* Encode u8 username_len */
2238   trunnel_assert(written <= avail);
2239   if (avail - written < 1)
2240     goto truncated;
2241   trunnel_set_uint8(ptr, (obj->username_len));
2242   written += 1; ptr += 1;
2243
2244   /* Encode char username[username_len] */
2245   {
2246     size_t elt_len = TRUNNEL_DYNARRAY_LEN(&obj->username);
2247     trunnel_assert(obj->username_len == elt_len);
2248     trunnel_assert(written <= avail);
2249     if (avail - written < elt_len)
2250       goto truncated;
2251     if (elt_len)
2252       memcpy(ptr, obj->username.elts_, elt_len);
2253     written += elt_len; ptr += elt_len;
2254   }
2255
2256   /* Encode u8 passwd_len */
2257   trunnel_assert(written <= avail);
2258   if (avail - written < 1)
2259     goto truncated;
2260   trunnel_set_uint8(ptr, (obj->passwd_len));
2261   written += 1; ptr += 1;
2262
2263   /* Encode char passwd[passwd_len] */
2264   {
2265     size_t elt_len = TRUNNEL_DYNARRAY_LEN(&obj->passwd);
2266     trunnel_assert(obj->passwd_len == elt_len);
2267     trunnel_assert(written <= avail);
2268     if (avail - written < elt_len)
2269       goto truncated;
2270     if (elt_len)
2271       memcpy(ptr, obj->passwd.elts_, elt_len);
2272     written += elt_len; ptr += elt_len;
2273   }
2274
2275
2276   trunnel_assert(ptr == output + written);
2277 #ifdef TRUNNEL_CHECK_ENCODED_LEN
2278   {
2279     trunnel_assert(encoded_len >= 0);
2280     trunnel_assert((size_t)encoded_len == written);
2281   }
2282
2283 #endif
2284
2285   return written;
2286
2287  truncated:
2288   result = -2;
2289   goto fail;
2290  check_failed:
2291   (void)msg;
2292   result = -1;
2293   goto fail;
2294  fail:
2295   trunnel_assert(result < 0);
2296   return result;
2297 }
2298
2299 /** As socks5_client_userpass_auth_parse(), but do not allocate the
2300  * output object.
2301  */
2302 static ssize_t
2303 socks5_client_userpass_auth_parse_into(socks5_client_userpass_auth_t *obj, const uint8_t *input, const size_t len_in)
2304 {
2305   const uint8_t *ptr = input;
2306   size_t remaining = len_in;
2307   ssize_t result = 0;
2308   (void)result;
2309
2310   /* Parse u8 version IN [1] */
2311   CHECK_REMAINING(1, truncated);
2312   obj->version = (trunnel_get_uint8(ptr));
2313   remaining -= 1; ptr += 1;
2314   if (! (obj->version == 1))
2315     goto fail;
2316
2317   /* Parse u8 username_len */
2318   CHECK_REMAINING(1, truncated);
2319   obj->username_len = (trunnel_get_uint8(ptr));
2320   remaining -= 1; ptr += 1;
2321
2322   /* Parse char username[username_len] */
2323   CHECK_REMAINING(obj->username_len, truncated);
2324   if (socks5_client_userpass_auth_setstr0_username(obj, (const char*)ptr, obj->username_len))
2325     goto fail;
2326   ptr += obj->username_len; remaining -= obj->username_len;
2327
2328   /* Parse u8 passwd_len */
2329   CHECK_REMAINING(1, truncated);
2330   obj->passwd_len = (trunnel_get_uint8(ptr));
2331   remaining -= 1; ptr += 1;
2332
2333   /* Parse char passwd[passwd_len] */
2334   CHECK_REMAINING(obj->passwd_len, truncated);
2335   if (socks5_client_userpass_auth_setstr0_passwd(obj, (const char*)ptr, obj->passwd_len))
2336     goto fail;
2337   ptr += obj->passwd_len; remaining -= obj->passwd_len;
2338   trunnel_assert(ptr + remaining == input + len_in);
2339   return len_in - remaining;
2340
2341  truncated:
2342   return -2;
2343  fail:
2344   result = -1;
2345   return result;
2346 }
2347
2348 ssize_t
2349 socks5_client_userpass_auth_parse(socks5_client_userpass_auth_t **output, const uint8_t *input, const size_t len_in)
2350 {
2351   ssize_t result;
2352   *output = socks5_client_userpass_auth_new();
2353   if (NULL == *output)
2354     return -1;
2355   result = socks5_client_userpass_auth_parse_into(*output, input, len_in);
2356   if (result < 0) {
2357     socks5_client_userpass_auth_free(*output);
2358     *output = NULL;
2359   }
2360   return result;
2361 }
2362 socks5_client_version_t *
2363 socks5_client_version_new(void)
2364 {
2365   socks5_client_version_t *val = trunnel_calloc(1, sizeof(socks5_client_version_t));
2366   if (NULL == val)
2367     return NULL;
2368   val->version = 5;
2369   return val;
2370 }
2371
2372 /** Release all storage held inside 'obj', but do not free 'obj'.
2373  */
2374 static void
2375 socks5_client_version_clear(socks5_client_version_t *obj)
2376 {
2377   (void) obj;
2378   TRUNNEL_DYNARRAY_WIPE(&obj->methods);
2379   TRUNNEL_DYNARRAY_CLEAR(&obj->methods);
2380 }
2381
2382 void
2383 socks5_client_version_free(socks5_client_version_t *obj)
2384 {
2385   if (obj == NULL)
2386     return;
2387   socks5_client_version_clear(obj);
2388   trunnel_memwipe(obj, sizeof(socks5_client_version_t));
2389   trunnel_free_(obj);
2390 }
2391
2392 uint8_t
2393 socks5_client_version_get_version(const socks5_client_version_t *inp)
2394 {
2395   return inp->version;
2396 }
2397 int
2398 socks5_client_version_set_version(socks5_client_version_t *inp, uint8_t val)
2399 {
2400   if (! ((val == 5))) {
2401      TRUNNEL_SET_ERROR_CODE(inp);
2402      return -1;
2403   }
2404   inp->version = val;
2405   return 0;
2406 }
2407 uint8_t
2408 socks5_client_version_get_n_methods(const socks5_client_version_t *inp)
2409 {
2410   return inp->n_methods;
2411 }
2412 int
2413 socks5_client_version_set_n_methods(socks5_client_version_t *inp, uint8_t val)
2414 {
2415   inp->n_methods = val;
2416   return 0;
2417 }
2418 size_t
2419 socks5_client_version_getlen_methods(const socks5_client_version_t *inp)
2420 {
2421   return TRUNNEL_DYNARRAY_LEN(&inp->methods);
2422 }
2423
2424 uint8_t
2425 socks5_client_version_get_methods(socks5_client_version_t *inp, size_t idx)
2426 {
2427   return TRUNNEL_DYNARRAY_GET(&inp->methods, idx);
2428 }
2429
2430 uint8_t
2431 socks5_client_version_getconst_methods(const socks5_client_version_t *inp, size_t idx)
2432 {
2433   return socks5_client_version_get_methods((socks5_client_version_t*)inp, idx);
2434 }
2435 int
2436 socks5_client_version_set_methods(socks5_client_version_t *inp, size_t idx, uint8_t elt)
2437 {
2438   TRUNNEL_DYNARRAY_SET(&inp->methods, idx, elt);
2439   return 0;
2440 }
2441 int
2442 socks5_client_version_add_methods(socks5_client_version_t *inp, uint8_t elt)
2443 {
2444 #if SIZE_MAX >= UINT8_MAX
2445   if (inp->methods.n_ == UINT8_MAX)
2446     goto trunnel_alloc_failed;
2447 #endif
2448   TRUNNEL_DYNARRAY_ADD(uint8_t, &inp->methods, elt, {});
2449   return 0;
2450  trunnel_alloc_failed:
2451   TRUNNEL_SET_ERROR_CODE(inp);
2452   return -1;
2453 }
2454
2455 uint8_t *
2456 socks5_client_version_getarray_methods(socks5_client_version_t *inp)
2457 {
2458   return inp->methods.elts_;
2459 }
2460 const uint8_t  *
2461 socks5_client_version_getconstarray_methods(const socks5_client_version_t *inp)
2462 {
2463   return (const uint8_t  *)socks5_client_version_getarray_methods((socks5_client_version_t*)inp);
2464 }
2465 int
2466 socks5_client_version_setlen_methods(socks5_client_version_t *inp, size_t newlen)
2467 {
2468   uint8_t *newptr;
2469 #if UINT8_MAX < SIZE_MAX
2470   if (newlen > UINT8_MAX)
2471     goto trunnel_alloc_failed;
2472 #endif
2473   newptr = trunnel_dynarray_setlen(&inp->methods.allocated_,
2474                  &inp->methods.n_, inp->methods.elts_, newlen,
2475                  sizeof(inp->methods.elts_[0]), (trunnel_free_fn_t) NULL,
2476                  &inp->trunnel_error_code_);
2477   if (newlen != 0 && newptr == NULL)
2478     goto trunnel_alloc_failed;
2479   inp->methods.elts_ = newptr;
2480   return 0;
2481  trunnel_alloc_failed:
2482   TRUNNEL_SET_ERROR_CODE(inp);
2483   return -1;
2484 }
2485 const char *
2486 socks5_client_version_check(const socks5_client_version_t *obj)
2487 {
2488   if (obj == NULL)
2489     return "Object was NULL";
2490   if (obj->trunnel_error_code_)
2491     return "A set function failed on this object";
2492   if (! (obj->version == 5))
2493     return "Integer out of bounds";
2494   if (TRUNNEL_DYNARRAY_LEN(&obj->methods) != obj->n_methods)
2495     return "Length mismatch for methods";
2496   return NULL;
2497 }
2498
2499 ssize_t
2500 socks5_client_version_encoded_len(const socks5_client_version_t *obj)
2501 {
2502   ssize_t result = 0;
2503
2504   if (NULL != socks5_client_version_check(obj))
2505      return -1;
2506
2507
2508   /* Length of u8 version IN [5] */
2509   result += 1;
2510
2511   /* Length of u8 n_methods */
2512   result += 1;
2513
2514   /* Length of u8 methods[n_methods] */
2515   result += TRUNNEL_DYNARRAY_LEN(&obj->methods);
2516   return result;
2517 }
2518 int
2519 socks5_client_version_clear_errors(socks5_client_version_t *obj)
2520 {
2521   int r = obj->trunnel_error_code_;
2522   obj->trunnel_error_code_ = 0;
2523   return r;
2524 }
2525 ssize_t
2526 socks5_client_version_encode(uint8_t *output, const size_t avail, const socks5_client_version_t *obj)
2527 {
2528   ssize_t result = 0;
2529   size_t written = 0;
2530   uint8_t *ptr = output;
2531   const char *msg;
2532 #ifdef TRUNNEL_CHECK_ENCODED_LEN
2533   const ssize_t encoded_len = socks5_client_version_encoded_len(obj);
2534 #endif
2535
2536   if (NULL != (msg = socks5_client_version_check(obj)))
2537     goto check_failed;
2538
2539 #ifdef TRUNNEL_CHECK_ENCODED_LEN
2540   trunnel_assert(encoded_len >= 0);
2541 #endif
2542
2543   /* Encode u8 version IN [5] */
2544   trunnel_assert(written <= avail);
2545   if (avail - written < 1)
2546     goto truncated;
2547   trunnel_set_uint8(ptr, (obj->version));
2548   written += 1; ptr += 1;
2549
2550   /* Encode u8 n_methods */
2551   trunnel_assert(written <= avail);
2552   if (avail - written < 1)
2553     goto truncated;
2554   trunnel_set_uint8(ptr, (obj->n_methods));
2555   written += 1; ptr += 1;
2556
2557   /* Encode u8 methods[n_methods] */
2558   {
2559     size_t elt_len = TRUNNEL_DYNARRAY_LEN(&obj->methods);
2560     trunnel_assert(obj->n_methods == elt_len);
2561     trunnel_assert(written <= avail);
2562     if (avail - written < elt_len)
2563       goto truncated;
2564     if (elt_len)
2565       memcpy(ptr, obj->methods.elts_, elt_len);
2566     written += elt_len; ptr += elt_len;
2567   }
2568
2569
2570   trunnel_assert(ptr == output + written);
2571 #ifdef TRUNNEL_CHECK_ENCODED_LEN
2572   {
2573     trunnel_assert(encoded_len >= 0);
2574     trunnel_assert((size_t)encoded_len == written);
2575   }
2576
2577 #endif
2578
2579   return written;
2580
2581  truncated:
2582   result = -2;
2583   goto fail;
2584  check_failed:
2585   (void)msg;
2586   result = -1;
2587   goto fail;
2588  fail:
2589   trunnel_assert(result < 0);
2590   return result;
2591 }
2592
2593 /** As socks5_client_version_parse(), but do not allocate the output
2594  * object.
2595  */
2596 static ssize_t
2597 socks5_client_version_parse_into(socks5_client_version_t *obj, const uint8_t *input, const size_t len_in)
2598 {
2599   const uint8_t *ptr = input;
2600   size_t remaining = len_in;
2601   ssize_t result = 0;
2602   (void)result;
2603
2604   /* Parse u8 version IN [5] */
2605   CHECK_REMAINING(1, truncated);
2606   obj->version = (trunnel_get_uint8(ptr));
2607   remaining -= 1; ptr += 1;
2608   if (! (obj->version == 5))
2609     goto fail;
2610
2611   /* Parse u8 n_methods */
2612   CHECK_REMAINING(1, truncated);
2613   obj->n_methods = (trunnel_get_uint8(ptr));
2614   remaining -= 1; ptr += 1;
2615
2616   /* Parse u8 methods[n_methods] */
2617   CHECK_REMAINING(obj->n_methods, truncated);
2618   TRUNNEL_DYNARRAY_EXPAND(uint8_t, &obj->methods, obj->n_methods, {});
2619   obj->methods.n_ = obj->n_methods;
2620   if (obj->n_methods)
2621     memcpy(obj->methods.elts_, ptr, obj->n_methods);
2622   ptr += obj->n_methods; remaining -= obj->n_methods;
2623   trunnel_assert(ptr + remaining == input + len_in);
2624   return len_in - remaining;
2625
2626  truncated:
2627   return -2;
2628  trunnel_alloc_failed:
2629   return -1;
2630  fail:
2631   result = -1;
2632   return result;
2633 }
2634
2635 ssize_t
2636 socks5_client_version_parse(socks5_client_version_t **output, const uint8_t *input, const size_t len_in)
2637 {
2638   ssize_t result;
2639   *output = socks5_client_version_new();
2640   if (NULL == *output)
2641     return -1;
2642   result = socks5_client_version_parse_into(*output, input, len_in);
2643   if (result < 0) {
2644     socks5_client_version_free(*output);
2645     *output = NULL;
2646   }
2647   return result;
2648 }
2649 socks5_server_method_t *
2650 socks5_server_method_new(void)
2651 {
2652   socks5_server_method_t *val = trunnel_calloc(1, sizeof(socks5_server_method_t));
2653   if (NULL == val)
2654     return NULL;
2655   val->version = 5;
2656   return val;
2657 }
2658
2659 /** Release all storage held inside 'obj', but do not free 'obj'.
2660  */
2661 static void
2662 socks5_server_method_clear(socks5_server_method_t *obj)
2663 {
2664   (void) obj;
2665 }
2666
2667 void
2668 socks5_server_method_free(socks5_server_method_t *obj)
2669 {
2670   if (obj == NULL)
2671     return;
2672   socks5_server_method_clear(obj);
2673   trunnel_memwipe(obj, sizeof(socks5_server_method_t));
2674   trunnel_free_(obj);
2675 }
2676
2677 uint8_t
2678 socks5_server_method_get_version(const socks5_server_method_t *inp)
2679 {
2680   return inp->version;
2681 }
2682 int
2683 socks5_server_method_set_version(socks5_server_method_t *inp, uint8_t val)
2684 {
2685   if (! ((val == 5))) {
2686      TRUNNEL_SET_ERROR_CODE(inp);
2687      return -1;
2688   }
2689   inp->version = val;
2690   return 0;
2691 }
2692 uint8_t
2693 socks5_server_method_get_method(const socks5_server_method_t *inp)
2694 {
2695   return inp->method;
2696 }
2697 int
2698 socks5_server_method_set_method(socks5_server_method_t *inp, uint8_t val)
2699 {
2700   inp->method = val;
2701   return 0;
2702 }
2703 const char *
2704 socks5_server_method_check(const socks5_server_method_t *obj)
2705 {
2706   if (obj == NULL)
2707     return "Object was NULL";
2708   if (obj->trunnel_error_code_)
2709     return "A set function failed on this object";
2710   if (! (obj->version == 5))
2711     return "Integer out of bounds";
2712   return NULL;
2713 }
2714
2715 ssize_t
2716 socks5_server_method_encoded_len(const socks5_server_method_t *obj)
2717 {
2718   ssize_t result = 0;
2719
2720   if (NULL != socks5_server_method_check(obj))
2721      return -1;
2722
2723
2724   /* Length of u8 version IN [5] */
2725   result += 1;
2726
2727   /* Length of u8 method */
2728   result += 1;
2729   return result;
2730 }
2731 int
2732 socks5_server_method_clear_errors(socks5_server_method_t *obj)
2733 {
2734   int r = obj->trunnel_error_code_;
2735   obj->trunnel_error_code_ = 0;
2736   return r;
2737 }
2738 ssize_t
2739 socks5_server_method_encode(uint8_t *output, const size_t avail, const socks5_server_method_t *obj)
2740 {
2741   ssize_t result = 0;
2742   size_t written = 0;
2743   uint8_t *ptr = output;
2744   const char *msg;
2745 #ifdef TRUNNEL_CHECK_ENCODED_LEN
2746   const ssize_t encoded_len = socks5_server_method_encoded_len(obj);
2747 #endif
2748
2749   if (NULL != (msg = socks5_server_method_check(obj)))
2750     goto check_failed;
2751
2752 #ifdef TRUNNEL_CHECK_ENCODED_LEN
2753   trunnel_assert(encoded_len >= 0);
2754 #endif
2755
2756   /* Encode u8 version IN [5] */
2757   trunnel_assert(written <= avail);
2758   if (avail - written < 1)
2759     goto truncated;
2760   trunnel_set_uint8(ptr, (obj->version));
2761   written += 1; ptr += 1;
2762
2763   /* Encode u8 method */
2764   trunnel_assert(written <= avail);
2765   if (avail - written < 1)
2766     goto truncated;
2767   trunnel_set_uint8(ptr, (obj->method));
2768   written += 1; ptr += 1;
2769
2770
2771   trunnel_assert(ptr == output + written);
2772 #ifdef TRUNNEL_CHECK_ENCODED_LEN
2773   {
2774     trunnel_assert(encoded_len >= 0);
2775     trunnel_assert((size_t)encoded_len == written);
2776   }
2777
2778 #endif
2779
2780   return written;
2781
2782  truncated:
2783   result = -2;
2784   goto fail;
2785  check_failed:
2786   (void)msg;
2787   result = -1;
2788   goto fail;
2789  fail:
2790   trunnel_assert(result < 0);
2791   return result;
2792 }
2793
2794 /** As socks5_server_method_parse(), but do not allocate the output
2795  * object.
2796  */
2797 static ssize_t
2798 socks5_server_method_parse_into(socks5_server_method_t *obj, const uint8_t *input, const size_t len_in)
2799 {
2800   const uint8_t *ptr = input;
2801   size_t remaining = len_in;
2802   ssize_t result = 0;
2803   (void)result;
2804
2805   /* Parse u8 version IN [5] */
2806   CHECK_REMAINING(1, truncated);
2807   obj->version = (trunnel_get_uint8(ptr));
2808   remaining -= 1; ptr += 1;
2809   if (! (obj->version == 5))
2810     goto fail;
2811
2812   /* Parse u8 method */
2813   CHECK_REMAINING(1, truncated);
2814   obj->method = (trunnel_get_uint8(ptr));
2815   remaining -= 1; ptr += 1;
2816   trunnel_assert(ptr + remaining == input + len_in);
2817   return len_in - remaining;
2818
2819  truncated:
2820   return -2;
2821  fail:
2822   result = -1;
2823   return result;
2824 }
2825
2826 ssize_t
2827 socks5_server_method_parse(socks5_server_method_t **output, const uint8_t *input, const size_t len_in)
2828 {
2829   ssize_t result;
2830   *output = socks5_server_method_new();
2831   if (NULL == *output)
2832     return -1;
2833   result = socks5_server_method_parse_into(*output, input, len_in);
2834   if (result < 0) {
2835     socks5_server_method_free(*output);
2836     *output = NULL;
2837   }
2838   return result;
2839 }
2840 socks5_server_userpass_auth_t *
2841 socks5_server_userpass_auth_new(void)
2842 {
2843   socks5_server_userpass_auth_t *val = trunnel_calloc(1, sizeof(socks5_server_userpass_auth_t));
2844   if (NULL == val)
2845     return NULL;
2846   val->version = 1;
2847   return val;
2848 }
2849
2850 /** Release all storage held inside 'obj', but do not free 'obj'.
2851  */
2852 static void
2853 socks5_server_userpass_auth_clear(socks5_server_userpass_auth_t *obj)
2854 {
2855   (void) obj;
2856 }
2857
2858 void
2859 socks5_server_userpass_auth_free(socks5_server_userpass_auth_t *obj)
2860 {
2861   if (obj == NULL)
2862     return;
2863   socks5_server_userpass_auth_clear(obj);
2864   trunnel_memwipe(obj, sizeof(socks5_server_userpass_auth_t));
2865   trunnel_free_(obj);
2866 }
2867
2868 uint8_t
2869 socks5_server_userpass_auth_get_version(const socks5_server_userpass_auth_t *inp)
2870 {
2871   return inp->version;
2872 }
2873 int
2874 socks5_server_userpass_auth_set_version(socks5_server_userpass_auth_t *inp, uint8_t val)
2875 {
2876   if (! ((val == 1))) {
2877      TRUNNEL_SET_ERROR_CODE(inp);
2878      return -1;
2879   }
2880   inp->version = val;
2881   return 0;
2882 }
2883 uint8_t
2884 socks5_server_userpass_auth_get_status(const socks5_server_userpass_auth_t *inp)
2885 {
2886   return inp->status;
2887 }
2888 int
2889 socks5_server_userpass_auth_set_status(socks5_server_userpass_auth_t *inp, uint8_t val)
2890 {
2891   inp->status = val;
2892   return 0;
2893 }
2894 const char *
2895 socks5_server_userpass_auth_check(const socks5_server_userpass_auth_t *obj)
2896 {
2897   if (obj == NULL)
2898     return "Object was NULL";
2899   if (obj->trunnel_error_code_)
2900     return "A set function failed on this object";
2901   if (! (obj->version == 1))
2902     return "Integer out of bounds";
2903   return NULL;
2904 }
2905
2906 ssize_t
2907 socks5_server_userpass_auth_encoded_len(const socks5_server_userpass_auth_t *obj)
2908 {
2909   ssize_t result = 0;
2910
2911   if (NULL != socks5_server_userpass_auth_check(obj))
2912      return -1;
2913
2914
2915   /* Length of u8 version IN [1] */
2916   result += 1;
2917
2918   /* Length of u8 status */
2919   result += 1;
2920   return result;
2921 }
2922 int
2923 socks5_server_userpass_auth_clear_errors(socks5_server_userpass_auth_t *obj)
2924 {
2925   int r = obj->trunnel_error_code_;
2926   obj->trunnel_error_code_ = 0;
2927   return r;
2928 }
2929 ssize_t
2930 socks5_server_userpass_auth_encode(uint8_t *output, const size_t avail, const socks5_server_userpass_auth_t *obj)
2931 {
2932   ssize_t result = 0;
2933   size_t written = 0;
2934   uint8_t *ptr = output;
2935   const char *msg;
2936 #ifdef TRUNNEL_CHECK_ENCODED_LEN
2937   const ssize_t encoded_len = socks5_server_userpass_auth_encoded_len(obj);
2938 #endif
2939
2940   if (NULL != (msg = socks5_server_userpass_auth_check(obj)))
2941     goto check_failed;
2942
2943 #ifdef TRUNNEL_CHECK_ENCODED_LEN
2944   trunnel_assert(encoded_len >= 0);
2945 #endif
2946
2947   /* Encode u8 version IN [1] */
2948   trunnel_assert(written <= avail);
2949   if (avail - written < 1)
2950     goto truncated;
2951   trunnel_set_uint8(ptr, (obj->version));
2952   written += 1; ptr += 1;
2953
2954   /* Encode u8 status */
2955   trunnel_assert(written <= avail);
2956   if (avail - written < 1)
2957     goto truncated;
2958   trunnel_set_uint8(ptr, (obj->status));
2959   written += 1; ptr += 1;
2960
2961
2962   trunnel_assert(ptr == output + written);
2963 #ifdef TRUNNEL_CHECK_ENCODED_LEN
2964   {
2965     trunnel_assert(encoded_len >= 0);
2966     trunnel_assert((size_t)encoded_len == written);
2967   }
2968
2969 #endif
2970
2971   return written;
2972
2973  truncated:
2974   result = -2;
2975   goto fail;
2976  check_failed:
2977   (void)msg;
2978   result = -1;
2979   goto fail;
2980  fail:
2981   trunnel_assert(result < 0);
2982   return result;
2983 }
2984
2985 /** As socks5_server_userpass_auth_parse(), but do not allocate the
2986  * output object.
2987  */
2988 static ssize_t
2989 socks5_server_userpass_auth_parse_into(socks5_server_userpass_auth_t *obj, const uint8_t *input, const size_t len_in)
2990 {
2991   const uint8_t *ptr = input;
2992   size_t remaining = len_in;
2993   ssize_t result = 0;
2994   (void)result;
2995
2996   /* Parse u8 version IN [1] */
2997   CHECK_REMAINING(1, truncated);
2998   obj->version = (trunnel_get_uint8(ptr));
2999   remaining -= 1; ptr += 1;
3000   if (! (obj->version == 1))
3001     goto fail;
3002
3003   /* Parse u8 status */
3004   CHECK_REMAINING(1, truncated);
3005   obj->status = (trunnel_get_uint8(ptr));
3006   remaining -= 1; ptr += 1;
3007   trunnel_assert(ptr + remaining == input + len_in);
3008   return len_in - remaining;
3009
3010  truncated:
3011   return -2;
3012  fail:
3013   result = -1;
3014   return result;
3015 }
3016
3017 ssize_t
3018 socks5_server_userpass_auth_parse(socks5_server_userpass_auth_t **output, const uint8_t *input, const size_t len_in)
3019 {
3020   ssize_t result;
3021   *output = socks5_server_userpass_auth_new();
3022   if (NULL == *output)
3023     return -1;
3024   result = socks5_server_userpass_auth_parse_into(*output, input, len_in);
3025   if (result < 0) {
3026     socks5_server_userpass_auth_free(*output);
3027     *output = NULL;
3028   }
3029   return result;
3030 }
3031 socks5_client_request_t *
3032 socks5_client_request_new(void)
3033 {
3034   socks5_client_request_t *val = trunnel_calloc(1, sizeof(socks5_client_request_t));
3035   if (NULL == val)
3036     return NULL;
3037   val->version = 5;
3038   val->command = CMD_BIND;
3039   return val;
3040 }
3041
3042 /** Release all storage held inside 'obj', but do not free 'obj'.
3043  */
3044 static void
3045 socks5_client_request_clear(socks5_client_request_t *obj)
3046 {
3047   (void) obj;
3048   domainname_free(obj->dest_addr_domainname);
3049   obj->dest_addr_domainname = NULL;
3050 }
3051
3052 void
3053 socks5_client_request_free(socks5_client_request_t *obj)
3054 {
3055   if (obj == NULL)
3056     return;
3057   socks5_client_request_clear(obj);
3058   trunnel_memwipe(obj, sizeof(socks5_client_request_t));
3059   trunnel_free_(obj);
3060 }
3061
3062 uint8_t
3063 socks5_client_request_get_version(const socks5_client_request_t *inp)
3064 {
3065   return inp->version;
3066 }
3067 int
3068 socks5_client_request_set_version(socks5_client_request_t *inp, uint8_t val)
3069 {
3070   if (! ((val == 5))) {
3071      TRUNNEL_SET_ERROR_CODE(inp);
3072      return -1;
3073   }
3074   inp->version = val;
3075   return 0;
3076 }
3077 uint8_t
3078 socks5_client_request_get_command(const socks5_client_request_t *inp)
3079 {
3080   return inp->command;
3081 }
3082 int
3083 socks5_client_request_set_command(socks5_client_request_t *inp, uint8_t val)
3084 {
3085   if (! ((val == CMD_BIND || val == CMD_CONNECT || val == CMD_RESOLVE || val == CMD_RESOLVE_PTR || val == CMD_UDP_ASSOCIATE))) {
3086      TRUNNEL_SET_ERROR_CODE(inp);
3087      return -1;
3088   }
3089   inp->command = val;
3090   return 0;
3091 }
3092 uint8_t
3093 socks5_client_request_get_reserved(const socks5_client_request_t *inp)
3094 {
3095   return inp->reserved;
3096 }
3097 int
3098 socks5_client_request_set_reserved(socks5_client_request_t *inp, uint8_t val)
3099 {
3100   if (! ((val == 0))) {
3101      TRUNNEL_SET_ERROR_CODE(inp);
3102      return -1;
3103   }
3104   inp->reserved = val;
3105   return 0;
3106 }
3107 uint8_t
3108 socks5_client_request_get_atype(const socks5_client_request_t *inp)
3109 {
3110   return inp->atype;
3111 }
3112 int
3113 socks5_client_request_set_atype(socks5_client_request_t *inp, uint8_t val)
3114 {
3115   inp->atype = val;
3116   return 0;
3117 }
3118 uint32_t
3119 socks5_client_request_get_dest_addr_ipv4(const socks5_client_request_t *inp)
3120 {
3121   return inp->dest_addr_ipv4;
3122 }
3123 int
3124 socks5_client_request_set_dest_addr_ipv4(socks5_client_request_t *inp, uint32_t val)
3125 {
3126   inp->dest_addr_ipv4 = val;
3127   return 0;
3128 }
3129 size_t
3130 socks5_client_request_getlen_dest_addr_ipv6(const socks5_client_request_t *inp)
3131 {
3132   (void)inp;  return 16;
3133 }
3134
3135 uint8_t
3136 socks5_client_request_get_dest_addr_ipv6(socks5_client_request_t *inp, size_t idx)
3137 {
3138   trunnel_assert(idx < 16);
3139   return inp->dest_addr_ipv6[idx];
3140 }
3141
3142 uint8_t
3143 socks5_client_request_getconst_dest_addr_ipv6(const socks5_client_request_t *inp, size_t idx)
3144 {
3145   return socks5_client_request_get_dest_addr_ipv6((socks5_client_request_t*)inp, idx);
3146 }
3147 int
3148 socks5_client_request_set_dest_addr_ipv6(socks5_client_request_t *inp, size_t idx, uint8_t elt)
3149 {
3150   trunnel_assert(idx < 16);
3151   inp->dest_addr_ipv6[idx] = elt;
3152   return 0;
3153 }
3154
3155 uint8_t *
3156 socks5_client_request_getarray_dest_addr_ipv6(socks5_client_request_t *inp)
3157 {
3158   return inp->dest_addr_ipv6;
3159 }
3160 const uint8_t  *
3161 socks5_client_request_getconstarray_dest_addr_ipv6(const socks5_client_request_t *inp)
3162 {
3163   return (const uint8_t  *)socks5_client_request_getarray_dest_addr_ipv6((socks5_client_request_t*)inp);
3164 }
3165 struct domainname_st *
3166 socks5_client_request_get_dest_addr_domainname(socks5_client_request_t *inp)
3167 {
3168   return inp->dest_addr_domainname;
3169 }
3170 const struct domainname_st *
3171 socks5_client_request_getconst_dest_addr_domainname(const socks5_client_request_t *inp)
3172 {
3173   return socks5_client_request_get_dest_addr_domainname((socks5_client_request_t*) inp);
3174 }
3175 int
3176 socks5_client_request_set_dest_addr_domainname(socks5_client_request_t *inp, struct domainname_st *val)
3177 {
3178   if (inp->dest_addr_domainname && inp->dest_addr_domainname != val)
3179     domainname_free(inp->dest_addr_domainname);
3180   return socks5_client_request_set0_dest_addr_domainname(inp, val);
3181 }
3182 int
3183 socks5_client_request_set0_dest_addr_domainname(socks5_client_request_t *inp, struct domainname_st *val)
3184 {
3185   inp->dest_addr_domainname = val;
3186   return 0;
3187 }
3188 uint16_t
3189 socks5_client_request_get_dest_port(const socks5_client_request_t *inp)
3190 {
3191   return inp->dest_port;
3192 }
3193 int
3194 socks5_client_request_set_dest_port(socks5_client_request_t *inp, uint16_t val)
3195 {
3196   inp->dest_port = val;
3197   return 0;
3198 }
3199 const char *
3200 socks5_client_request_check(const socks5_client_request_t *obj)
3201 {
3202   if (obj == NULL)
3203     return "Object was NULL";
3204   if (obj->trunnel_error_code_)
3205     return "A set function failed on this object";
3206   if (! (obj->version == 5))
3207     return "Integer out of bounds";
3208   if (! (obj->command == CMD_BIND || obj->command == CMD_CONNECT || obj->command == CMD_RESOLVE || obj->command == CMD_RESOLVE_PTR || obj->command == CMD_UDP_ASSOCIATE))
3209     return "Integer out of bounds";
3210   if (! (obj->reserved == 0))
3211     return "Integer out of bounds";
3212   switch (obj->atype) {
3213
3214     case ATYPE_IPV4:
3215       break;
3216
3217     case ATYPE_IPV6:
3218       break;
3219
3220     case ATYPE_DOMAINNAME:
3221       {
3222         const char *msg;
3223         if (NULL != (msg = domainname_check(obj->dest_addr_domainname)))
3224           return msg;
3225       }
3226       break;
3227
3228     default:
3229         return "Bad tag for union";
3230       break;
3231   }
3232   return NULL;
3233 }
3234
3235 ssize_t
3236 socks5_client_request_encoded_len(const socks5_client_request_t *obj)
3237 {
3238   ssize_t result = 0;
3239
3240   if (NULL != socks5_client_request_check(obj))
3241      return -1;
3242
3243
3244   /* Length of u8 version IN [5] */
3245   result += 1;
3246
3247   /* Length of u8 command IN [CMD_BIND, CMD_CONNECT, CMD_RESOLVE, CMD_RESOLVE_PTR, CMD_UDP_ASSOCIATE] */
3248   result += 1;
3249
3250   /* Length of u8 reserved IN [0] */
3251   result += 1;
3252
3253   /* Length of u8 atype */
3254   result += 1;
3255   switch (obj->atype) {
3256
3257     case ATYPE_IPV4:
3258
3259       /* Length of u32 dest_addr_ipv4 */
3260       result += 4;
3261       break;
3262
3263     case ATYPE_IPV6:
3264
3265       /* Length of u8 dest_addr_ipv6[16] */
3266       result += 16;
3267       break;
3268
3269     case ATYPE_DOMAINNAME:
3270
3271       /* Length of struct domainname dest_addr_domainname */
3272       result += domainname_encoded_len(obj->dest_addr_domainname);
3273       break;
3274
3275     default:
3276       trunnel_assert(0);
3277       break;
3278   }
3279
3280   /* Length of u16 dest_port */
3281   result += 2;
3282   return result;
3283 }
3284 int
3285 socks5_client_request_clear_errors(socks5_client_request_t *obj)
3286 {
3287   int r = obj->trunnel_error_code_;
3288   obj->trunnel_error_code_ = 0;
3289   return r;
3290 }
3291 ssize_t
3292 socks5_client_request_encode(uint8_t *output, const size_t avail, const socks5_client_request_t *obj)
3293 {
3294   ssize_t result = 0;
3295   size_t written = 0;
3296   uint8_t *ptr = output;
3297   const char *msg;
3298 #ifdef TRUNNEL_CHECK_ENCODED_LEN
3299   const ssize_t encoded_len = socks5_client_request_encoded_len(obj);
3300 #endif
3301
3302   if (NULL != (msg = socks5_client_request_check(obj)))
3303     goto check_failed;
3304
3305 #ifdef TRUNNEL_CHECK_ENCODED_LEN
3306   trunnel_assert(encoded_len >= 0);
3307 #endif
3308
3309   /* Encode u8 version IN [5] */
3310   trunnel_assert(written <= avail);
3311   if (avail - written < 1)
3312     goto truncated;
3313   trunnel_set_uint8(ptr, (obj->version));
3314   written += 1; ptr += 1;
3315
3316   /* Encode u8 command IN [CMD_BIND, CMD_CONNECT, CMD_RESOLVE, CMD_RESOLVE_PTR, CMD_UDP_ASSOCIATE] */
3317   trunnel_assert(written <= avail);
3318   if (avail - written < 1)
3319     goto truncated;
3320   trunnel_set_uint8(ptr, (obj->command));
3321   written += 1; ptr += 1;
3322
3323   /* Encode u8 reserved IN [0] */
3324   trunnel_assert(written <= avail);
3325   if (avail - written < 1)
3326     goto truncated;
3327   trunnel_set_uint8(ptr, (obj->reserved));
3328   written += 1; ptr += 1;
3329
3330   /* Encode u8 atype */
3331   trunnel_assert(written <= avail);
3332   if (avail - written < 1)
3333     goto truncated;
3334   trunnel_set_uint8(ptr, (obj->atype));
3335   written += 1; ptr += 1;
3336
3337   /* Encode union dest_addr[atype] */
3338   trunnel_assert(written <= avail);
3339   switch (obj->atype) {
3340
3341     case ATYPE_IPV4:
3342
3343       /* Encode u32 dest_addr_ipv4 */
3344       trunnel_assert(written <= avail);
3345       if (avail - written < 4)
3346         goto truncated;
3347       trunnel_set_uint32(ptr, trunnel_htonl(obj->dest_addr_ipv4));
3348       written += 4; ptr += 4;
3349       break;
3350
3351     case ATYPE_IPV6:
3352
3353       /* Encode u8 dest_addr_ipv6[16] */
3354       trunnel_assert(written <= avail);
3355       if (avail - written < 16)
3356         goto truncated;
3357       memcpy(ptr, obj->dest_addr_ipv6, 16);
3358       written += 16; ptr += 16;
3359       break;
3360
3361     case ATYPE_DOMAINNAME:
3362
3363       /* Encode struct domainname dest_addr_domainname */
3364       trunnel_assert(written <= avail);
3365       result = domainname_encode(ptr, avail - written, obj->dest_addr_domainname);
3366       if (result < 0)
3367         goto fail; /* XXXXXXX !*/
3368       written += result; ptr += result;
3369       break;
3370
3371     default:
3372       trunnel_assert(0);
3373       break;
3374   }
3375
3376   /* Encode u16 dest_port */
3377   trunnel_assert(written <= avail);
3378   if (avail - written < 2)
3379     goto truncated;
3380   trunnel_set_uint16(ptr, trunnel_htons(obj->dest_port));
3381   written += 2; ptr += 2;
3382
3383
3384   trunnel_assert(ptr == output + written);
3385 #ifdef TRUNNEL_CHECK_ENCODED_LEN
3386   {
3387     trunnel_assert(encoded_len >= 0);
3388     trunnel_assert((size_t)encoded_len == written);
3389   }
3390
3391 #endif
3392
3393   return written;
3394
3395  truncated:
3396   result = -2;
3397   goto fail;
3398  check_failed:
3399   (void)msg;
3400   result = -1;
3401   goto fail;
3402  fail:
3403   trunnel_assert(result < 0);
3404   return result;
3405 }
3406
3407 /** As socks5_client_request_parse(), but do not allocate the output
3408  * object.
3409  */
3410 static ssize_t
3411 socks5_client_request_parse_into(socks5_client_request_t *obj, const uint8_t *input, const size_t len_in)
3412 {
3413   const uint8_t *ptr = input;
3414   size_t remaining = len_in;
3415   ssize_t result = 0;
3416   (void)result;
3417
3418   /* Parse u8 version IN [5] */
3419   CHECK_REMAINING(1, truncated);
3420   obj->version = (trunnel_get_uint8(ptr));
3421   remaining -= 1; ptr += 1;
3422   if (! (obj->version == 5))
3423     goto fail;
3424
3425   /* Parse u8 command IN [CMD_BIND, CMD_CONNECT, CMD_RESOLVE, CMD_RESOLVE_PTR, CMD_UDP_ASSOCIATE] */
3426   CHECK_REMAINING(1, truncated);
3427   obj->command = (trunnel_get_uint8(ptr));
3428   remaining -= 1; ptr += 1;
3429   if (! (obj->command == CMD_BIND || obj->command == CMD_CONNECT || obj->command == CMD_RESOLVE || obj->command == CMD_RESOLVE_PTR || obj->command == CMD_UDP_ASSOCIATE))
3430     goto fail;
3431
3432   /* Parse u8 reserved IN [0] */
3433   CHECK_REMAINING(1, truncated);
3434   obj->reserved = (trunnel_get_uint8(ptr));
3435   remaining -= 1; ptr += 1;
3436   if (! (obj->reserved == 0))
3437     goto fail;
3438
3439   /* Parse u8 atype */
3440   CHECK_REMAINING(1, truncated);
3441   obj->atype = (trunnel_get_uint8(ptr));
3442   remaining -= 1; ptr += 1;
3443
3444   /* Parse union dest_addr[atype] */
3445   switch (obj->atype) {
3446
3447     case ATYPE_IPV4:
3448
3449       /* Parse u32 dest_addr_ipv4 */
3450       CHECK_REMAINING(4, truncated);
3451       obj->dest_addr_ipv4 = trunnel_ntohl(trunnel_get_uint32(ptr));
3452       remaining -= 4; ptr += 4;
3453       break;
3454
3455     case ATYPE_IPV6:
3456
3457       /* Parse u8 dest_addr_ipv6[16] */
3458       CHECK_REMAINING(16, truncated);
3459       memcpy(obj->dest_addr_ipv6, ptr, 16);
3460       remaining -= 16; ptr += 16;
3461       break;
3462
3463     case ATYPE_DOMAINNAME:
3464
3465       /* Parse struct domainname dest_addr_domainname */
3466       result = domainname_parse(&obj->dest_addr_domainname, ptr, remaining);
3467       if (result < 0)
3468         goto relay_fail;
3469       trunnel_assert((size_t)result <= remaining);
3470       remaining -= result; ptr += result;
3471       break;
3472
3473     default:
3474       goto fail;
3475       break;
3476   }
3477
3478   /* Parse u16 dest_port */
3479   CHECK_REMAINING(2, truncated);
3480   obj->dest_port = trunnel_ntohs(trunnel_get_uint16(ptr));
3481   remaining -= 2; ptr += 2;
3482   trunnel_assert(ptr + remaining == input + len_in);
3483   return len_in - remaining;
3484
3485  truncated:
3486   return -2;
3487  relay_fail:
3488   trunnel_assert(result < 0);
3489   return result;
3490  fail:
3491   result = -1;
3492   return result;
3493 }
3494
3495 ssize_t
3496 socks5_client_request_parse(socks5_client_request_t **output, const uint8_t *input, const size_t len_in)
3497 {
3498   ssize_t result;
3499   *output = socks5_client_request_new();
3500   if (NULL == *output)
3501     return -1;
3502   result = socks5_client_request_parse_into(*output, input, len_in);
3503   if (result < 0) {
3504     socks5_client_request_free(*output);
3505     *output = NULL;
3506   }
3507   return result;
3508 }
3509 socks5_server_reply_t *
3510 socks5_server_reply_new(void)
3511 {
3512   socks5_server_reply_t *val = trunnel_calloc(1, sizeof(socks5_server_reply_t));
3513   if (NULL == val)
3514     return NULL;
3515   val->version = 5;
3516   return val;
3517 }
3518
3519 /** Release all storage held inside 'obj', but do not free 'obj'.
3520  */
3521 static void
3522 socks5_server_reply_clear(socks5_server_reply_t *obj)
3523 {
3524   (void) obj;
3525   domainname_free(obj->bind_addr_domainname);
3526   obj->bind_addr_domainname = NULL;
3527 }
3528
3529 void
3530 socks5_server_reply_free(socks5_server_reply_t *obj)
3531 {
3532   if (obj == NULL)
3533     return;
3534   socks5_server_reply_clear(obj);
3535   trunnel_memwipe(obj, sizeof(socks5_server_reply_t));
3536   trunnel_free_(obj);
3537 }
3538
3539 uint8_t
3540 socks5_server_reply_get_version(const socks5_server_reply_t *inp)
3541 {
3542   return inp->version;
3543 }
3544 int
3545 socks5_server_reply_set_version(socks5_server_reply_t *inp, uint8_t val)
3546 {
3547   if (! ((val == 5))) {
3548      TRUNNEL_SET_ERROR_CODE(inp);
3549      return -1;
3550   }
3551   inp->version = val;
3552   return 0;
3553 }
3554 uint8_t
3555 socks5_server_reply_get_reply(const socks5_server_reply_t *inp)
3556 {
3557   return inp->reply;
3558 }
3559 int
3560 socks5_server_reply_set_reply(socks5_server_reply_t *inp, uint8_t val)
3561 {
3562   inp->reply = val;
3563   return 0;
3564 }
3565 uint8_t
3566 socks5_server_reply_get_reserved(const socks5_server_reply_t *inp)
3567 {
3568   return inp->reserved;
3569 }
3570 int
3571 socks5_server_reply_set_reserved(socks5_server_reply_t *inp, uint8_t val)
3572 {
3573   if (! ((val == 0))) {
3574      TRUNNEL_SET_ERROR_CODE(inp);
3575      return -1;
3576   }
3577   inp->reserved = val;
3578   return 0;
3579 }
3580 uint8_t
3581 socks5_server_reply_get_atype(const socks5_server_reply_t *inp)
3582 {
3583   return inp->atype;
3584 }
3585 int
3586 socks5_server_reply_set_atype(socks5_server_reply_t *inp, uint8_t val)
3587 {
3588   inp->atype = val;
3589   return 0;
3590 }
3591 uint32_t
3592 socks5_server_reply_get_bind_addr_ipv4(const socks5_server_reply_t *inp)
3593 {
3594   return inp->bind_addr_ipv4;
3595 }
3596 int
3597 socks5_server_reply_set_bind_addr_ipv4(socks5_server_reply_t *inp, uint32_t val)
3598 {
3599   inp->bind_addr_ipv4 = val;
3600   return 0;
3601 }
3602 size_t
3603 socks5_server_reply_getlen_bind_addr_ipv6(const socks5_server_reply_t *inp)
3604 {
3605   (void)inp;  return 16;
3606 }
3607
3608 uint8_t
3609 socks5_server_reply_get_bind_addr_ipv6(socks5_server_reply_t *inp, size_t idx)
3610 {
3611   trunnel_assert(idx < 16);
3612   return inp->bind_addr_ipv6[idx];
3613 }
3614
3615 uint8_t
3616 socks5_server_reply_getconst_bind_addr_ipv6(const socks5_server_reply_t *inp, size_t idx)
3617 {
3618   return socks5_server_reply_get_bind_addr_ipv6((socks5_server_reply_t*)inp, idx);
3619 }
3620 int
3621 socks5_server_reply_set_bind_addr_ipv6(socks5_server_reply_t *inp, size_t idx, uint8_t elt)
3622 {
3623   trunnel_assert(idx < 16);
3624   inp->bind_addr_ipv6[idx] = elt;
3625   return 0;
3626 }
3627
3628 uint8_t *
3629 socks5_server_reply_getarray_bind_addr_ipv6(socks5_server_reply_t *inp)
3630 {
3631   return inp->bind_addr_ipv6;
3632 }
3633 const uint8_t  *
3634 socks5_server_reply_getconstarray_bind_addr_ipv6(const socks5_server_reply_t *inp)
3635 {
3636   return (const uint8_t  *)socks5_server_reply_getarray_bind_addr_ipv6((socks5_server_reply_t*)inp);
3637 }
3638 struct domainname_st *
3639 socks5_server_reply_get_bind_addr_domainname(socks5_server_reply_t *inp)
3640 {
3641   return inp->bind_addr_domainname;
3642 }
3643 const struct domainname_st *
3644 socks5_server_reply_getconst_bind_addr_domainname(const socks5_server_reply_t *inp)
3645 {
3646   return socks5_server_reply_get_bind_addr_domainname((socks5_server_reply_t*) inp);
3647 }
3648 int
3649 socks5_server_reply_set_bind_addr_domainname(socks5_server_reply_t *inp, struct domainname_st *val)
3650 {
3651   if (inp->bind_addr_domainname && inp->bind_addr_domainname != val)
3652     domainname_free(inp->bind_addr_domainname);
3653   return socks5_server_reply_set0_bind_addr_domainname(inp, val);
3654 }
3655 int
3656 socks5_server_reply_set0_bind_addr_domainname(socks5_server_reply_t *inp, struct domainname_st *val)
3657 {
3658   inp->bind_addr_domainname = val;
3659   return 0;
3660 }
3661 uint16_t
3662 socks5_server_reply_get_bind_port(const socks5_server_reply_t *inp)
3663 {
3664   return inp->bind_port;
3665 }
3666 int
3667 socks5_server_reply_set_bind_port(socks5_server_reply_t *inp, uint16_t val)
3668 {
3669   inp->bind_port = val;
3670   return 0;
3671 }
3672 const char *
3673 socks5_server_reply_check(const socks5_server_reply_t *obj)
3674 {
3675   if (obj == NULL)
3676     return "Object was NULL";
3677   if (obj->trunnel_error_code_)
3678     return "A set function failed on this object";
3679   if (! (obj->version == 5))
3680     return "Integer out of bounds";
3681   if (! (obj->reserved == 0))
3682     return "Integer out of bounds";
3683   switch (obj->atype) {
3684
3685     case ATYPE_IPV4:
3686       break;
3687
3688     case ATYPE_IPV6:
3689       break;
3690
3691     case ATYPE_DOMAINNAME:
3692       {
3693         const char *msg;
3694         if (NULL != (msg = domainname_check(obj->bind_addr_domainname)))
3695           return msg;
3696       }
3697       break;
3698
3699     default:
3700         return "Bad tag for union";
3701       break;
3702   }
3703   return NULL;
3704 }
3705
3706 ssize_t
3707 socks5_server_reply_encoded_len(const socks5_server_reply_t *obj)
3708 {
3709   ssize_t result = 0;
3710
3711   if (NULL != socks5_server_reply_check(obj))
3712      return -1;
3713
3714
3715   /* Length of u8 version IN [5] */
3716   result += 1;
3717
3718   /* Length of u8 reply */
3719   result += 1;
3720
3721   /* Length of u8 reserved IN [0] */
3722   result += 1;
3723
3724   /* Length of u8 atype */
3725   result += 1;
3726   switch (obj->atype) {
3727
3728     case ATYPE_IPV4:
3729
3730       /* Length of u32 bind_addr_ipv4 */
3731       result += 4;
3732       break;
3733
3734     case ATYPE_IPV6:
3735
3736       /* Length of u8 bind_addr_ipv6[16] */
3737       result += 16;
3738       break;
3739
3740     case ATYPE_DOMAINNAME:
3741
3742       /* Length of struct domainname bind_addr_domainname */
3743       result += domainname_encoded_len(obj->bind_addr_domainname);
3744       break;
3745
3746     default:
3747       trunnel_assert(0);
3748       break;
3749   }
3750
3751   /* Length of u16 bind_port */
3752   result += 2;
3753   return result;
3754 }
3755 int
3756 socks5_server_reply_clear_errors(socks5_server_reply_t *obj)
3757 {
3758   int r = obj->trunnel_error_code_;
3759   obj->trunnel_error_code_ = 0;
3760   return r;
3761 }
3762 ssize_t
3763 socks5_server_reply_encode(uint8_t *output, const size_t avail, const socks5_server_reply_t *obj)
3764 {
3765   ssize_t result = 0;
3766   size_t written = 0;
3767   uint8_t *ptr = output;
3768   const char *msg;
3769 #ifdef TRUNNEL_CHECK_ENCODED_LEN
3770   const ssize_t encoded_len = socks5_server_reply_encoded_len(obj);
3771 #endif
3772
3773   if (NULL != (msg = socks5_server_reply_check(obj)))
3774     goto check_failed;
3775
3776 #ifdef TRUNNEL_CHECK_ENCODED_LEN
3777   trunnel_assert(encoded_len >= 0);
3778 #endif
3779
3780   /* Encode u8 version IN [5] */
3781   trunnel_assert(written <= avail);
3782   if (avail - written < 1)
3783     goto truncated;
3784   trunnel_set_uint8(ptr, (obj->version));
3785   written += 1; ptr += 1;
3786
3787   /* Encode u8 reply */
3788   trunnel_assert(written <= avail);
3789   if (avail - written < 1)
3790     goto truncated;
3791   trunnel_set_uint8(ptr, (obj->reply));
3792   written += 1; ptr += 1;
3793
3794   /* Encode u8 reserved IN [0] */
3795   trunnel_assert(written <= avail);
3796   if (avail - written < 1)
3797     goto truncated;
3798   trunnel_set_uint8(ptr, (obj->reserved));
3799   written += 1; ptr += 1;
3800
3801   /* Encode u8 atype */
3802   trunnel_assert(written <= avail);
3803   if (avail - written < 1)
3804     goto truncated;
3805   trunnel_set_uint8(ptr, (obj->atype));
3806   written += 1; ptr += 1;
3807
3808   /* Encode union bind_addr[atype] */
3809   trunnel_assert(written <= avail);
3810   switch (obj->atype) {
3811
3812     case ATYPE_IPV4:
3813
3814       /* Encode u32 bind_addr_ipv4 */
3815       trunnel_assert(written <= avail);
3816       if (avail - written < 4)
3817         goto truncated;
3818       trunnel_set_uint32(ptr, trunnel_htonl(obj->bind_addr_ipv4));
3819       written += 4; ptr += 4;
3820       break;
3821
3822     case ATYPE_IPV6:
3823
3824       /* Encode u8 bind_addr_ipv6[16] */
3825       trunnel_assert(written <= avail);
3826       if (avail - written < 16)
3827         goto truncated;
3828       memcpy(ptr, obj->bind_addr_ipv6, 16);
3829       written += 16; ptr += 16;
3830       break;
3831
3832     case ATYPE_DOMAINNAME:
3833
3834       /* Encode struct domainname bind_addr_domainname */
3835       trunnel_assert(written <= avail);
3836       result = domainname_encode(ptr, avail - written, obj->bind_addr_domainname);
3837       if (result < 0)
3838         goto fail; /* XXXXXXX !*/
3839       written += result; ptr += result;
3840       break;
3841
3842     default:
3843       trunnel_assert(0);
3844       break;
3845   }
3846
3847   /* Encode u16 bind_port */
3848   trunnel_assert(written <= avail);
3849   if (avail - written < 2)
3850     goto truncated;
3851   trunnel_set_uint16(ptr, trunnel_htons(obj->bind_port));
3852   written += 2; ptr += 2;
3853
3854
3855   trunnel_assert(ptr == output + written);
3856 #ifdef TRUNNEL_CHECK_ENCODED_LEN
3857   {
3858     trunnel_assert(encoded_len >= 0);
3859     trunnel_assert((size_t)encoded_len == written);
3860   }
3861
3862 #endif
3863
3864   return written;
3865
3866  truncated:
3867   result = -2;
3868   goto fail;
3869  check_failed:
3870   (void)msg;
3871   result = -1;
3872   goto fail;
3873  fail:
3874   trunnel_assert(result < 0);
3875   return result;
3876 }
3877
3878 /** As socks5_server_reply_parse(), but do not allocate the output
3879  * object.
3880  */
3881 static ssize_t
3882 socks5_server_reply_parse_into(socks5_server_reply_t *obj, const uint8_t *input, const size_t len_in)
3883 {
3884   const uint8_t *ptr = input;
3885   size_t remaining = len_in;
3886   ssize_t result = 0;
3887   (void)result;
3888
3889   /* Parse u8 version IN [5] */
3890   CHECK_REMAINING(1, truncated);
3891   obj->version = (trunnel_get_uint8(ptr));
3892   remaining -= 1; ptr += 1;
3893   if (! (obj->version == 5))
3894     goto fail;
3895
3896   /* Parse u8 reply */
3897   CHECK_REMAINING(1, truncated);
3898   obj->reply = (trunnel_get_uint8(ptr));
3899   remaining -= 1; ptr += 1;
3900
3901   /* Parse u8 reserved IN [0] */
3902   CHECK_REMAINING(1, truncated);
3903   obj->reserved = (trunnel_get_uint8(ptr));
3904   remaining -= 1; ptr += 1;
3905   if (! (obj->reserved == 0))
3906     goto fail;
3907
3908   /* Parse u8 atype */
3909   CHECK_REMAINING(1, truncated);
3910   obj->atype = (trunnel_get_uint8(ptr));
3911   remaining -= 1; ptr += 1;
3912
3913   /* Parse union bind_addr[atype] */
3914   switch (obj->atype) {
3915
3916     case ATYPE_IPV4:
3917
3918       /* Parse u32 bind_addr_ipv4 */
3919       CHECK_REMAINING(4, truncated);
3920       obj->bind_addr_ipv4 = trunnel_ntohl(trunnel_get_uint32(ptr));
3921       remaining -= 4; ptr += 4;
3922       break;
3923
3924     case ATYPE_IPV6:
3925
3926       /* Parse u8 bind_addr_ipv6[16] */
3927       CHECK_REMAINING(16, truncated);
3928       memcpy(obj->bind_addr_ipv6, ptr, 16);
3929       remaining -= 16; ptr += 16;
3930       break;
3931
3932     case ATYPE_DOMAINNAME:
3933
3934       /* Parse struct domainname bind_addr_domainname */
3935       result = domainname_parse(&obj->bind_addr_domainname, ptr, remaining);
3936       if (result < 0)
3937         goto relay_fail;
3938       trunnel_assert((size_t)result <= remaining);
3939       remaining -= result; ptr += result;
3940       break;
3941
3942     default:
3943       goto fail;
3944       break;
3945   }
3946
3947   /* Parse u16 bind_port */
3948   CHECK_REMAINING(2, truncated);
3949   obj->bind_port = trunnel_ntohs(trunnel_get_uint16(ptr));
3950   remaining -= 2; ptr += 2;
3951   trunnel_assert(ptr + remaining == input + len_in);
3952   return len_in - remaining;
3953
3954  truncated:
3955   return -2;
3956  relay_fail:
3957   trunnel_assert(result < 0);
3958   return result;
3959  fail:
3960   result = -1;
3961   return result;
3962 }
3963
3964 ssize_t
3965 socks5_server_reply_parse(socks5_server_reply_t **output, const uint8_t *input, const size_t len_in)
3966 {
3967   ssize_t result;
3968   *output = socks5_server_reply_new();
3969   if (NULL == *output)
3970     return -1;
3971   result = socks5_server_reply_parse_into(*output, input, len_in);
3972   if (result < 0) {
3973     socks5_server_reply_free(*output);
3974     *output = NULL;
3975   }
3976   return result;
3977 }