ext/Socket/Socket.xs

   1 #define PERL_NO_GET_CONTEXT
   2 #include "EXTERN.h"
   3 #include "perl.h"
   4 #include "XSUB.h"
   5
   6 #ifndef VMS
   7 # ifdef I_SYS_TYPES
   8 #  include <sys/types.h>
   9 # endif
  10 # include <sys/socket.h>
  11 # if defined(USE_SOCKS) && defined(I_SOCKS)
  12 #   include <socks.h>
  13 # endif
  14 # ifdef MPE
  15 #  define PF_INET AF_INET
  16 #  define PF_UNIX AF_UNIX
  17 #  define SOCK_RAW 3
  18 # endif
  19 # ifdef I_SYS_UN
  20 #  include <sys/un.h>
  21 # endif
  22 /* XXX Configure test for <netinet/in_systm.h needed XXX */
  23 # if defined(NeXT) || defined(__NeXT__)
  24 #  include <netinet/in_systm.h>
  25 # endif
  26 # ifdef I_NETINET_IN
  27 #  include <netinet/in.h>
  28 # endif
  29 # ifdef I_NETDB
  30 #  include <netdb.h>
  31 # endif
  32 # ifdef I_ARPA_INET
  33 #  include <arpa/inet.h>
  34 # endif
  35 # ifdef I_NETINET_TCP
  36 #  include <netinet/tcp.h>
  37 # endif
  38 #else
  39 # include "sockadapt.h"
  40 #endif
  41
  42 #ifdef I_SYSUIO
  43 # include <sys/uio.h>
  44 #endif
  45
  46 #ifndef AF_NBS
  47 # undef PF_NBS
  48 #endif
  49
  50 #ifndef AF_X25
  51 # undef PF_X25
  52 #endif
  53
  54 #ifndef INADDR_NONE
  55 # define INADDR_NONE    0xffffffff
  56 #endif /* INADDR_NONE */
  57 #ifndef INADDR_BROADCAST
  58 # define INADDR_BROADCAST       0xffffffff
  59 #endif /* INADDR_BROADCAST */
  60 #ifndef INADDR_LOOPBACK
  61 # define INADDR_LOOPBACK         0x7F000001
  62 #endif /* INADDR_LOOPBACK */
  63
  64 #ifndef HAS_INET_ATON
  65
  66 /*
  67  * Check whether "cp" is a valid ascii representation
  68  * of an Internet address and convert to a binary address.
  69  * Returns 1 if the address is valid, 0 if not.
  70  * This replaces inet_addr, the return value from which
  71  * cannot distinguish between failure and a local broadcast address.
  72  */
  73 static int
  74 my_inet_aton(register const char *cp, struct in_addr *addr)
  75 {
  76         dTHX;
  77         register U32 val;
  78         register int base;
  79         register char c;
  80         int nparts;
  81         const char *s;
  82         unsigned int parts[4];
  83         register unsigned int *pp = parts;
  84
  85         if (!cp)
  86                 return 0;
  87         for (;;) {
  88                 /*
  89                  * Collect number up to ``.''.
  90                  * Values are specified as for C:
  91                  * 0x=hex, 0=octal, other=decimal.
  92                  */
  93                 val = 0; base = 10;
  94                 if (*cp == '0') {
  95                         if (*++cp == 'x' || *cp == 'X')
  96                                 base = 16, cp++;
  97                         else
  98                                 base = 8;
  99                 }
 100                 while ((c = *cp) != '\0') {
 101                         if (isDIGIT(c)) {
 102                                 val = (val * base) + (c - '0');
 103                                 cp++;
 104                                 continue;
 105                         }
 106                         if (base == 16 && (s=strchr(PL_hexdigit,c))) {
 107                                 val = (val << 4) +
 108                                         ((s - PL_hexdigit) & 15);
 109                                 cp++;
 110                                 continue;
 111                         }
 112                         break;
 113                 }
 114                 if (*cp == '.') {
 115                         /*
 116                          * Internet format:
 117                          *      a.b.c.d
 118                          *      a.b.c   (with c treated as 16-bits)
 119                          *      a.b     (with b treated as 24 bits)
 120                          */
 121                         if (pp >= parts + 3 || val > 0xff)
 122                                 return 0;
 123                         *pp++ = val, cp++;
 124                 } else
 125                         break;
 126         }
 127         /*
 128          * Check for trailing characters.
 129          */
 130         if (*cp && !isSPACE(*cp))
 131                 return 0;
 132         /*
 133          * Concoct the address according to
 134          * the number of parts specified.
 135          */
 136         nparts = pp - parts + 1;        /* force to an int for switch() */
 137         switch (nparts) {
 138
 139         case 1:                         /* a -- 32 bits */
 140                 break;
 141
 142         case 2:                         /* a.b -- 8.24 bits */
 143                 if (val > 0xffffff)
 144                         return 0;
 145                 val |= parts[0] << 24;
 146                 break;
 147
 148         case 3:                         /* a.b.c -- 8.8.16 bits */
 149                 if (val > 0xffff)
 150                         return 0;
 151                 val |= (parts[0] << 24) | (parts[1] << 16);
 152                 break;
 153
 154         case 4:                         /* a.b.c.d -- 8.8.8.8 bits */
 155                 if (val > 0xff)
 156                         return 0;
 157                 val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
 158                 break;
 159         }
 160         addr->s_addr = htonl(val);
 161         return 1;
 162 }
 163
 164 #undef inet_aton
 165 #define inet_aton my_inet_aton
 166
 167 #endif /* ! HAS_INET_ATON */
 168
 169
 170 static int
 171 not_here(char *s)
 172 {
 173     croak("Socket::%s not implemented on this architecture", s);
 174     return -1;
 175 }
 176
 177 #define PERL_constant_NOTFOUND  1
 178 #define PERL_constant_NOTDEF    2
 179 #define PERL_constant_ISIV      3
 180 #define PERL_constant_ISNO      4
 181 #define PERL_constant_ISNV      5
 182 #define PERL_constant_ISPV      6
 183 #define PERL_constant_ISPVN     7
 184 #define PERL_constant_ISSV      8
 185 #define PERL_constant_ISUNDEF   9
 186 #define PERL_constant_ISUV      10
 187 #define PERL_constant_ISYES     11
 188
 189 static int
 190 constant_6 (pTHX_ const char *name, IV *iv_return, SV **sv_return) {
 191   /* When generated this function returned values for the list of names given
 192      here.  However, subsequent manual editing may have added or removed some.
 193      AF_802 AF_DLI AF_LAT AF_MAX AF_NBS AF_NIT AF_OSI AF_PUP AF_SNA AF_X25
 194      PF_802 PF_DLI PF_LAT PF_MAX PF_NBS PF_NIT PF_OSI PF_PUP PF_SNA PF_X25 */
 195   /* Offset 3 gives the best switch position.  */
 196   switch (name[3]) {
 197   case '8':
 198     if (memEQ(name, "AF_802", 6)) {
 199     /*                  ^        */
 200 #ifdef AF_802
 201       *iv_return = AF_802;
 202       return PERL_constant_ISIV;
 203 #else
 204       return PERL_constant_NOTDEF;
 205 #endif
 206     }
 207     if (memEQ(name, "PF_802", 6)) {
 208     /*                  ^        */
 209 #ifdef PF_802
 210       *iv_return = PF_802;
 211       return PERL_constant_ISIV;
 212 #else
 213       return PERL_constant_NOTDEF;
 214 #endif
 215     }
 216     break;
 217   case 'D':
 218     if (memEQ(name, "AF_DLI", 6)) {
 219     /*                  ^        */
 220 #ifdef AF_DLI
 221       *iv_return = AF_DLI;
 222       return PERL_constant_ISIV;
 223 #else
 224       return PERL_constant_NOTDEF;
 225 #endif
 226     }
 227     if (memEQ(name, "PF_DLI", 6)) {
 228     /*                  ^        */
 229 #ifdef PF_DLI
 230       *iv_return = PF_DLI;
 231       return PERL_constant_ISIV;
 232 #else
 233       return PERL_constant_NOTDEF;
 234 #endif
 235     }
 236     break;
 237   case 'L':
 238     if (memEQ(name, "AF_LAT", 6)) {
 239     /*                  ^        */
 240 #ifdef AF_LAT
 241       *iv_return = AF_LAT;
 242       return PERL_constant_ISIV;
 243 #else
 244       return PERL_constant_NOTDEF;
 245 #endif
 246     }
 247     if (memEQ(name, "PF_LAT", 6)) {
 248     /*                  ^        */
 249 #ifdef PF_LAT
 250       *iv_return = PF_LAT;
 251       return PERL_constant_ISIV;
 252 #else
 253       return PERL_constant_NOTDEF;
 254 #endif
 255     }
 256     break;
 257   case 'M':
 258     if (memEQ(name, "AF_MAX", 6)) {
 259     /*                  ^        */
 260 #ifdef AF_MAX
 261       *iv_return = AF_MAX;
 262       return PERL_constant_ISIV;
 263 #else
 264       return PERL_constant_NOTDEF;
 265 #endif
 266     }
 267     if (memEQ(name, "PF_MAX", 6)) {
 268     /*                  ^        */
 269 #ifdef PF_MAX
 270       *iv_return = PF_MAX;
 271       return PERL_constant_ISIV;
 272 #else
 273       return PERL_constant_NOTDEF;
 274 #endif
 275     }
 276     break;
 277   case 'N':
 278     if (memEQ(name, "AF_NBS", 6)) {
 279     /*                  ^        */
 280 #ifdef AF_NBS
 281       *iv_return = AF_NBS;
 282       return PERL_constant_ISIV;
 283 #else
 284       return PERL_constant_NOTDEF;
 285 #endif
 286     }
 287     if (memEQ(name, "AF_NIT", 6)) {
 288     /*                  ^        */
 289 #ifdef AF_NIT
 290       *iv_return = AF_NIT;
 291       return PERL_constant_ISIV;
 292 #else
 293       return PERL_constant_NOTDEF;
 294 #endif
 295     }
 296     if (memEQ(name, "PF_NBS", 6)) {
 297     /*                  ^        */
 298 #ifdef PF_NBS
 299       *iv_return = PF_NBS;
 300       return PERL_constant_ISIV;
 301 #else
 302       return PERL_constant_NOTDEF;
 303 #endif
 304     }
 305     if (memEQ(name, "PF_NIT", 6)) {
 306     /*                  ^        */
 307 #ifdef PF_NIT
 308       *iv_return = PF_NIT;
 309       return PERL_constant_ISIV;
 310 #else
 311       return PERL_constant_NOTDEF;
 312 #endif
 313     }
 314     break;
 315   case 'O':
 316     if (memEQ(name, "AF_OSI", 6)) {
 317     /*                  ^        */
 318 #ifdef AF_OSI
 319       *iv_return = AF_OSI;
 320       return PERL_constant_ISIV;
 321 #else
 322       return PERL_constant_NOTDEF;
 323 #endif
 324     }
 325     if (memEQ(name, "PF_OSI", 6)) {
 326     /*                  ^        */
 327 #ifdef PF_OSI
 328       *iv_return = PF_OSI;
 329       return PERL_constant_ISIV;
 330 #else
 331       return PERL_constant_NOTDEF;
 332 #endif
 333     }
 334     break;
 335   case 'P':
 336     if (memEQ(name, "AF_PUP", 6)) {
 337     /*                  ^        */
 338 #ifdef AF_PUP
 339       *iv_return = AF_PUP;
 340       return PERL_constant_ISIV;
 341 #else
 342       return PERL_constant_NOTDEF;
 343 #endif
 344     }
 345     if (memEQ(name, "PF_PUP", 6)) {
 346     /*                  ^        */
 347 #ifdef PF_PUP
 348       *iv_return = PF_PUP;
 349       return PERL_constant_ISIV;
 350 #else
 351       return PERL_constant_NOTDEF;
 352 #endif
 353     }
 354     break;
 355   case 'S':
 356     if (memEQ(name, "AF_SNA", 6)) {
 357     /*                  ^        */
 358 #ifdef AF_SNA
 359       *iv_return = AF_SNA;
 360       return PERL_constant_ISIV;
 361 #else
 362       return PERL_constant_NOTDEF;
 363 #endif
 364     }
 365     if (memEQ(name, "PF_SNA", 6)) {
 366     /*                  ^        */
 367 #ifdef PF_SNA
 368       *iv_return = PF_SNA;
 369       return PERL_constant_ISIV;
 370 #else
 371       return PERL_constant_NOTDEF;
 372 #endif
 373     }
 374     break;
 375   case 'X':
 376     if (memEQ(name, "AF_X25", 6)) {
 377     /*                  ^        */
 378 #ifdef AF_X25
 379       *iv_return = AF_X25;
 380       return PERL_constant_ISIV;
 381 #else
 382       return PERL_constant_NOTDEF;
 383 #endif
 384     }
 385     if (memEQ(name, "PF_X25", 6)) {
 386     /*                  ^        */
 387 #ifdef PF_X25
 388       *iv_return = PF_X25;
 389       return PERL_constant_ISIV;
 390 #else
 391       return PERL_constant_NOTDEF;
 392 #endif
 393     }
 394     break;
 395   }
 396   return PERL_constant_NOTFOUND;
 397 }
 398
 399 static int
 400 constant_7 (pTHX_ const char *name, IV *iv_return, SV **sv_return) {
 401   /* When generated this function returned values for the list of names given
 402      here.  However, subsequent manual editing may have added or removed some.
 403      AF_ECMA AF_INET AF_UNIX IOV_MAX MSG_EOF MSG_EOR MSG_FIN MSG_OOB MSG_RST
 404      MSG_SYN MSG_URG PF_ECMA PF_INET PF_UNIX SHUT_RD SHUT_WR SO_TYPE */
 405   /* Offset 4 gives the best switch position.  */
 406   switch (name[4]) {
 407   case 'C':
 408     if (memEQ(name, "AF_ECMA", 7)) {
 409     /*                   ^        */
 410 #ifdef AF_ECMA
 411       *iv_return = AF_ECMA;
 412       return PERL_constant_ISIV;
 413 #else
 414       return PERL_constant_NOTDEF;
 415 #endif
 416     }
 417     if (memEQ(name, "PF_ECMA", 7)) {
 418     /*                   ^        */
 419 #ifdef PF_ECMA
 420       *iv_return = PF_ECMA;
 421       return PERL_constant_ISIV;
 422 #else
 423       return PERL_constant_NOTDEF;
 424 #endif
 425     }
 426     break;
 427   case 'E':
 428     if (memEQ(name, "MSG_EOF", 7)) {
 429     /*                   ^        */
 430 #ifdef MSG_EOF
 431       *iv_return = MSG_EOF;
 432       return PERL_constant_ISIV;
 433 #else
 434       return PERL_constant_NOTDEF;
 435 #endif
 436     }
 437     if (memEQ(name, "MSG_EOR", 7)) {
 438     /*                   ^        */
 439 #ifdef MSG_EOR
 440       *iv_return = MSG_EOR;
 441       return PERL_constant_ISIV;
 442 #else
 443       return PERL_constant_NOTDEF;
 444 #endif
 445     }
 446     break;
 447   case 'F':
 448     if (memEQ(name, "MSG_FIN", 7)) {
 449     /*                   ^        */
 450 #ifdef MSG_FIN
 451       *iv_return = MSG_FIN;
 452       return PERL_constant_ISIV;
 453 #else
 454       return PERL_constant_NOTDEF;
 455 #endif
 456     }
 457     break;
 458   case 'M':
 459     if (memEQ(name, "IOV_MAX", 7)) {
 460     /*                   ^        */
 461 #ifdef IOV_MAX
 462       *iv_return = IOV_MAX;
 463       return PERL_constant_ISIV;
 464 #else
 465       return PERL_constant_NOTDEF;
 466 #endif
 467     }
 468     break;
 469   case 'N':
 470     if (memEQ(name, "AF_INET", 7)) {
 471     /*                   ^        */
 472 #ifdef AF_INET
 473       *iv_return = AF_INET;
 474       return PERL_constant_ISIV;
 475 #else
 476       return PERL_constant_NOTDEF;
 477 #endif
 478     }
 479     if (memEQ(name, "AF_UNIX", 7)) {
 480     /*                   ^        */
 481 #ifdef AF_UNIX
 482       *iv_return = AF_UNIX;
 483       return PERL_constant_ISIV;
 484 #else
 485       return PERL_constant_NOTDEF;
 486 #endif
 487     }
 488     if (memEQ(name, "PF_INET", 7)) {
 489     /*                   ^        */
 490 #ifdef PF_INET
 491       *iv_return = PF_INET;
 492       return PERL_constant_ISIV;
 493 #else
 494       return PERL_constant_NOTDEF;
 495 #endif
 496     }
 497     if (memEQ(name, "PF_UNIX", 7)) {
 498     /*                   ^        */
 499 #ifdef PF_UNIX
 500       *iv_return = PF_UNIX;
 501       return PERL_constant_ISIV;
 502 #else
 503       return PERL_constant_NOTDEF;
 504 #endif
 505     }
 506     break;
 507   case 'O':
 508     if (memEQ(name, "MSG_OOB", 7)) {
 509     /*                   ^        */
 510 #if defined(MSG_OOB) || defined(HAS_MSG_OOB) /* might be an enum */
 511       *iv_return = MSG_OOB;
 512       return PERL_constant_ISIV;
 513 #else
 514       return PERL_constant_NOTDEF;
 515 #endif
 516     }
 517     break;
 518   case 'R':
 519     if (memEQ(name, "MSG_RST", 7)) {
 520     /*                   ^        */
 521 #ifdef MSG_RST
 522       *iv_return = MSG_RST;
 523       return PERL_constant_ISIV;
 524 #else
 525       return PERL_constant_NOTDEF;
 526 #endif
 527     }
 528     break;
 529   case 'S':
 530     if (memEQ(name, "MSG_SYN", 7)) {
 531     /*                   ^        */
 532 #ifdef MSG_SYN
 533       *iv_return = MSG_SYN;
 534       return PERL_constant_ISIV;
 535 #else
 536       return PERL_constant_NOTDEF;
 537 #endif
 538     }
 539     break;
 540   case 'U':
 541     if (memEQ(name, "MSG_URG", 7)) {
 542     /*                   ^        */
 543 #ifdef MSG_URG
 544       *iv_return = MSG_URG;
 545       return PERL_constant_ISIV;
 546 #else
 547       return PERL_constant_NOTDEF;
 548 #endif
 549     }
 550     break;
 551   case 'Y':
 552     if (memEQ(name, "SO_TYPE", 7)) {
 553     /*                   ^        */
 554 #ifdef SO_TYPE
 555       *iv_return = SO_TYPE;
 556       return PERL_constant_ISIV;
 557 #else
 558       return PERL_constant_NOTDEF;
 559 #endif
 560     }
 561     break;
 562   case '_':
 563     if (memEQ(name, "SHUT_RD", 7)) {
 564     /*                   ^        */
 565 #ifdef SHUT_RD
 566       *iv_return = SHUT_RD;
 567       return PERL_constant_ISIV;
 568 #else
 569       *iv_return = 0;
 570       return PERL_constant_ISIV;
 571 #endif
 572     }
 573     if (memEQ(name, "SHUT_WR", 7)) {
 574     /*                   ^        */
 575 #ifdef SHUT_WR
 576       *iv_return = SHUT_WR;
 577       return PERL_constant_ISIV;
 578 #else
 579       *iv_return = 1;
 580       return PERL_constant_ISIV;
 581 #endif
 582     }
 583     break;
 584   }
 585   return PERL_constant_NOTFOUND;
 586 }
 587
 588 static int
 589 constant_8 (pTHX_ const char *name, IV *iv_return, SV **sv_return) {
 590   /* When generated this function returned values for the list of names given
 591      here.  However, subsequent manual editing may have added or removed some.
 592      AF_CCITT AF_CHAOS AF_GOSIP MSG_PEEK PF_CCITT PF_CHAOS PF_GOSIP SOCK_RAW
 593      SOCK_RDM SO_DEBUG SO_ERROR */
 594   /* Offset 7 gives the best switch position.  */
 595   switch (name[7]) {
 596   case 'G':
 597     if (memEQ(name, "SO_DEBUG", 8)) {
 598     /*                      ^      */
 599 #ifdef SO_DEBUG
 600       *iv_return = SO_DEBUG;
 601       return PERL_constant_ISIV;
 602 #else
 603       return PERL_constant_NOTDEF;
 604 #endif
 605     }
 606     break;
 607   case 'K':
 608     if (memEQ(name, "MSG_PEEK", 8)) {
 609     /*                      ^      */
 610 #if defined(MSG_PEEK) || defined(HAS_MSG_PEEK) /* might be an enum */
 611       *iv_return = MSG_PEEK;
 612       return PERL_constant_ISIV;
 613 #else
 614       return PERL_constant_NOTDEF;
 615 #endif
 616     }
 617     break;
 618   case 'M':
 619     if (memEQ(name, "SOCK_RDM", 8)) {
 620     /*                      ^      */
 621 #ifdef SOCK_RDM
 622       *iv_return = SOCK_RDM;
 623       return PERL_constant_ISIV;
 624 #else
 625       return PERL_constant_NOTDEF;
 626 #endif
 627     }
 628     break;
 629   case 'P':
 630     if (memEQ(name, "AF_GOSIP", 8)) {
 631     /*                      ^      */
 632 #ifdef AF_GOSIP
 633       *iv_return = AF_GOSIP;
 634       return PERL_constant_ISIV;
 635 #else
 636       return PERL_constant_NOTDEF;
 637 #endif
 638     }
 639     if (memEQ(name, "PF_GOSIP", 8)) {
 640     /*                      ^      */
 641 #ifdef PF_GOSIP
 642       *iv_return = PF_GOSIP;
 643       return PERL_constant_ISIV;
 644 #else
 645       return PERL_constant_NOTDEF;
 646 #endif
 647     }
 648     break;
 649   case 'R':
 650     if (memEQ(name, "SO_ERROR", 8)) {
 651     /*                      ^      */
 652 #ifdef SO_ERROR
 653       *iv_return = SO_ERROR;
 654       return PERL_constant_ISIV;
 655 #else
 656       return PERL_constant_NOTDEF;
 657 #endif
 658     }
 659     break;
 660   case 'S':
 661     if (memEQ(name, "AF_CHAOS", 8)) {
 662     /*                      ^      */
 663 #ifdef AF_CHAOS
 664       *iv_return = AF_CHAOS;
 665       return PERL_constant_ISIV;
 666 #else
 667       return PERL_constant_NOTDEF;
 668 #endif
 669     }
 670     if (memEQ(name, "PF_CHAOS", 8)) {
 671     /*                      ^      */
 672 #ifdef PF_CHAOS
 673       *iv_return = PF_CHAOS;
 674       return PERL_constant_ISIV;
 675 #else
 676       return PERL_constant_NOTDEF;
 677 #endif
 678     }
 679     break;
 680   case 'T':
 681     if (memEQ(name, "AF_CCITT", 8)) {
 682     /*                      ^      */
 683 #ifdef AF_CCITT
 684       *iv_return = AF_CCITT;
 685       return PERL_constant_ISIV;
 686 #else
 687       return PERL_constant_NOTDEF;
 688 #endif
 689     }
 690     if (memEQ(name, "PF_CCITT", 8)) {
 691     /*                      ^      */
 692 #ifdef PF_CCITT
 693       *iv_return = PF_CCITT;
 694       return PERL_constant_ISIV;
 695 #else
 696       return PERL_constant_NOTDEF;
 697 #endif
 698     }
 699     break;
 700   case 'W':
 701     if (memEQ(name, "SOCK_RAW", 8)) {
 702     /*                      ^      */
 703 #ifdef SOCK_RAW
 704       *iv_return = SOCK_RAW;
 705       return PERL_constant_ISIV;
 706 #else
 707       return PERL_constant_NOTDEF;
 708 #endif
 709     }
 710     break;
 711   }
 712   return PERL_constant_NOTFOUND;
 713 }
 714
 715 static int
 716 constant_9 (pTHX_ const char *name, IV *iv_return, SV **sv_return) {
 717   /* When generated this function returned values for the list of names given
 718      here.  However, subsequent manual editing may have added or removed some.
 719      AF_DECnet AF_HYLINK AF_OSINET AF_UNSPEC MSG_BCAST MSG_MCAST MSG_PROXY
 720      MSG_TRUNC PF_DECnet PF_HYLINK PF_OSINET PF_UNSPEC SCM_CREDS SHUT_RDWR
 721      SOMAXCONN SO_LINGER SO_RCVBUF SO_SNDBUF TCP_MAXRT */
 722   /* Offset 6 gives the best switch position.  */
 723   switch (name[6]) {
 724   case 'A':
 725     if (memEQ(name, "MSG_BCAST", 9)) {
 726     /*                     ^        */
 727 #ifdef MSG_BCAST
 728       *iv_return = MSG_BCAST;
 729       return PERL_constant_ISIV;
 730 #else
 731       return PERL_constant_NOTDEF;
 732 #endif
 733     }
 734     if (memEQ(name, "MSG_MCAST", 9)) {
 735     /*                     ^        */
 736 #ifdef MSG_MCAST
 737       *iv_return = MSG_MCAST;
 738       return PERL_constant_ISIV;
 739 #else
 740       return PERL_constant_NOTDEF;
 741 #endif
 742     }
 743     break;
 744   case 'B':
 745     if (memEQ(name, "SO_RCVBUF", 9)) {
 746     /*                     ^        */
 747 #ifdef SO_RCVBUF
 748       *iv_return = SO_RCVBUF;
 749       return PERL_constant_ISIV;
 750 #else
 751       return PERL_constant_NOTDEF;
 752 #endif
 753     }
 754     if (memEQ(name, "SO_SNDBUF", 9)) {
 755     /*                     ^        */
 756 #ifdef SO_SNDBUF
 757       *iv_return = SO_SNDBUF;
 758       return PERL_constant_ISIV;
 759 #else
 760       return PERL_constant_NOTDEF;
 761 #endif
 762     }
 763     break;
 764   case 'D':
 765     if (memEQ(name, "SHUT_RDWR", 9)) {
 766     /*                     ^        */
 767 #ifdef SHUT_RDWR
 768       *iv_return = SHUT_RDWR;
 769       return PERL_constant_ISIV;
 770 #else
 771       *iv_return = 2;
 772       return PERL_constant_ISIV;
 773 #endif
 774     }
 775     break;
 776   case 'E':
 777     if (memEQ(name, "SCM_CREDS", 9)) {
 778     /*                     ^        */
 779 #ifdef SCM_CREDS
 780       *iv_return = SCM_CREDS;
 781       return PERL_constant_ISIV;
 782 #else
 783       return PERL_constant_NOTDEF;
 784 #endif
 785     }
 786     break;
 787   case 'G':
 788     if (memEQ(name, "SO_LINGER", 9)) {
 789     /*                     ^        */
 790 #ifdef SO_LINGER
 791       *iv_return = SO_LINGER;
 792       return PERL_constant_ISIV;
 793 #else
 794       return PERL_constant_NOTDEF;
 795 #endif
 796     }
 797     break;
 798   case 'I':
 799     if (memEQ(name, "AF_HYLINK", 9)) {
 800     /*                     ^        */
 801 #ifdef AF_HYLINK
 802       *iv_return = AF_HYLINK;
 803       return PERL_constant_ISIV;
 804 #else
 805       return PERL_constant_NOTDEF;
 806 #endif
 807     }
 808     if (memEQ(name, "PF_HYLINK", 9)) {
 809     /*                     ^        */
 810 #ifdef PF_HYLINK
 811       *iv_return = PF_HYLINK;
 812       return PERL_constant_ISIV;
 813 #else
 814       return PERL_constant_NOTDEF;
 815 #endif
 816     }
 817     break;
 818   case 'N':
 819     if (memEQ(name, "AF_OSINET", 9)) {
 820     /*                     ^        */
 821 #ifdef AF_OSINET
 822       *iv_return = AF_OSINET;
 823       return PERL_constant_ISIV;
 824 #else
 825       return PERL_constant_NOTDEF;
 826 #endif
 827     }
 828     if (memEQ(name, "PF_OSINET", 9)) {
 829     /*                     ^        */
 830 #ifdef PF_OSINET
 831       *iv_return = PF_OSINET;
 832       return PERL_constant_ISIV;
 833 #else
 834       return PERL_constant_NOTDEF;
 835 #endif
 836     }
 837     break;
 838   case 'O':
 839     if (memEQ(name, "MSG_PROXY", 9)) {
 840     /*                     ^        */
 841 #if defined(MSG_PROXY) || defined(HAS_MSG_PROXY) /* might be an enum */
 842       *iv_return = MSG_PROXY;
 843       return PERL_constant_ISIV;
 844 #else
 845       return PERL_constant_NOTDEF;
 846 #endif
 847     }
 848     if (memEQ(name, "SOMAXCONN", 9)) {
 849     /*                     ^        */
 850 #ifdef SOMAXCONN
 851       *iv_return = SOMAXCONN;
 852       return PERL_constant_ISIV;
 853 #else
 854       return PERL_constant_NOTDEF;
 855 #endif
 856     }
 857     break;
 858   case 'P':
 859     if (memEQ(name, "AF_UNSPEC", 9)) {
 860     /*                     ^        */
 861 #ifdef AF_UNSPEC
 862       *iv_return = AF_UNSPEC;
 863       return PERL_constant_ISIV;
 864 #else
 865       return PERL_constant_NOTDEF;
 866 #endif
 867     }
 868     if (memEQ(name, "PF_UNSPEC", 9)) {
 869     /*                     ^        */
 870 #ifdef PF_UNSPEC
 871       *iv_return = PF_UNSPEC;
 872       return PERL_constant_ISIV;
 873 #else
 874       return PERL_constant_NOTDEF;
 875 #endif
 876     }
 877     break;
 878   case 'U':
 879     if (memEQ(name, "MSG_TRUNC", 9)) {
 880     /*                     ^        */
 881 #ifdef MSG_TRUNC
 882       *iv_return = MSG_TRUNC;
 883       return PERL_constant_ISIV;
 884 #else
 885       return PERL_constant_NOTDEF;
 886 #endif
 887     }
 888     break;
 889   case 'X':
 890     if (memEQ(name, "TCP_MAXRT", 9)) {
 891     /*                     ^        */
 892 #ifdef TCP_MAXRT
 893       *iv_return = TCP_MAXRT;
 894       return PERL_constant_ISIV;
 895 #else
 896       return PERL_constant_NOTDEF;
 897 #endif
 898     }
 899     break;
 900   case 'n':
 901     if (memEQ(name, "AF_DECnet", 9)) {
 902     /*                     ^        */
 903 #ifdef AF_DECnet
 904       *iv_return = AF_DECnet;
 905       return PERL_constant_ISIV;
 906 #else
 907       return PERL_constant_NOTDEF;
 908 #endif
 909     }
 910     if (memEQ(name, "PF_DECnet", 9)) {
 911     /*                     ^        */
 912 #ifdef PF_DECnet
 913       *iv_return = PF_DECnet;
 914       return PERL_constant_ISIV;
 915 #else
 916       return PERL_constant_NOTDEF;
 917 #endif
 918     }
 919     break;
 920   }
 921   return PERL_constant_NOTFOUND;
 922 }
 923
 924 static int
 925 constant_10 (pTHX_ const char *name, IV *iv_return, SV **sv_return) {
 926   /* When generated this function returned values for the list of names given
 927      here.  However, subsequent manual editing may have added or removed some.
 928      AF_DATAKIT AF_IMPLINK INADDR_ANY MSG_CTRUNC PF_DATAKIT PF_IMPLINK
 929      SCM_RIGHTS SOCK_DGRAM SOL_SOCKET TCP_MAXSEG TCP_STDURG UIO_MAXIOV */
 930   /* Offset 6 gives the best switch position.  */
 931   switch (name[6]) {
 932   case 'A':
 933     if (memEQ(name, "AF_DATAKIT", 10)) {
 934     /*                     ^          */
 935 #ifdef AF_DATAKIT
 936       *iv_return = AF_DATAKIT;
 937       return PERL_constant_ISIV;
 938 #else
 939       return PERL_constant_NOTDEF;
 940 #endif
 941     }
 942     if (memEQ(name, "PF_DATAKIT", 10)) {
 943     /*                     ^          */
 944 #ifdef PF_DATAKIT
 945       *iv_return = PF_DATAKIT;
 946       return PERL_constant_ISIV;
 947 #else
 948       return PERL_constant_NOTDEF;
 949 #endif
 950     }
 951     break;
 952   case 'C':
 953     if (memEQ(name, "SOL_SOCKET", 10)) {
 954     /*                     ^          */
 955 #ifdef SOL_SOCKET
 956       *iv_return = SOL_SOCKET;
 957       return PERL_constant_ISIV;
 958 #else
 959       return PERL_constant_NOTDEF;
 960 #endif
 961     }
 962     break;
 963   case 'D':
 964     if (memEQ(name, "TCP_STDURG", 10)) {
 965     /*                     ^          */
 966 #ifdef TCP_STDURG
 967       *iv_return = TCP_STDURG;
 968       return PERL_constant_ISIV;
 969 #else
 970       return PERL_constant_NOTDEF;
 971 #endif
 972     }
 973     break;
 974   case 'G':
 975     if (memEQ(name, "SCM_RIGHTS", 10)) {
 976     /*                     ^          */
 977 #if defined(SCM_RIGHTS) || defined(HAS_SCM_RIGHTS) /* might be an enum */
 978       *iv_return = SCM_RIGHTS;
 979       return PERL_constant_ISIV;
 980 #else
 981       return PERL_constant_NOTDEF;
 982 #endif
 983     }
 984     if (memEQ(name, "SOCK_DGRAM", 10)) {
 985     /*                     ^          */
 986 #ifdef SOCK_DGRAM
 987       *iv_return = SOCK_DGRAM;
 988       return PERL_constant_ISIV;
 989 #else
 990       return PERL_constant_NOTDEF;
 991 #endif
 992     }
 993     break;
 994   case 'L':
 995     if (memEQ(name, "AF_IMPLINK", 10)) {
 996     /*                     ^          */
 997 #ifdef AF_IMPLINK
 998       *iv_return = AF_IMPLINK;
 999       return PERL_constant_ISIV;
1000 #else
1001       return PERL_constant_NOTDEF;
1002 #endif
1003     }
1004     if (memEQ(name, "PF_IMPLINK", 10)) {
1005     /*                     ^          */
1006 #ifdef PF_IMPLINK
1007       *iv_return = PF_IMPLINK;
1008       return PERL_constant_ISIV;
1009 #else
1010       return PERL_constant_NOTDEF;
1011 #endif
1012     }
1013     break;
1014   case 'R':
1015     if (memEQ(name, "MSG_CTRUNC", 10)) {
1016     /*                     ^          */
1017 #if defined(MSG_CTRUNC) || defined(HAS_MSG_CTRUNC) /* might be an enum */
1018       *iv_return = MSG_CTRUNC;
1019       return PERL_constant_ISIV;
1020 #else
1021       return PERL_constant_NOTDEF;
1022 #endif
1023     }
1024     break;
1025   case 'X':
1026     if (memEQ(name, "TCP_MAXSEG", 10)) {
1027     /*                     ^          */
1028 #ifdef TCP_MAXSEG
1029       *iv_return = TCP_MAXSEG;
1030       return PERL_constant_ISIV;
1031 #else
1032       return PERL_constant_NOTDEF;
1033 #endif
1034     }
1035     if (memEQ(name, "UIO_MAXIOV", 10)) {
1036     /*                     ^          */
1037 #ifdef UIO_MAXIOV
1038       *iv_return = UIO_MAXIOV;
1039       return PERL_constant_ISIV;
1040 #else
1041       return PERL_constant_NOTDEF;
1042 #endif
1043     }
1044     break;
1045   case '_':
1046     if (memEQ(name, "INADDR_ANY", 10)) {
1047     /*                     ^          */
1048 #ifdef INADDR_ANY
1049       {
1050 struct in_addr ip_address; ip_address.s_addr = htonl(INADDR_ANY);
1051         *sv_return =  sv_2mortal(newSVpvn((char *)&ip_address,sizeof ip_address ));
1052         return PERL_constant_ISSV;
1053       }
1054 #else
1055       return PERL_constant_NOTDEF;
1056 #endif
1057     }
1058     break;
1059   }
1060   return PERL_constant_NOTFOUND;
1061 }
1062
1063 static int
1064 constant_11 (pTHX_ const char *name, IV *iv_return, SV **sv_return) {
1065   /* When generated this function returned values for the list of names given
1066      here.  However, subsequent manual editing may have added or removed some.
1067      INADDR_NONE IPPROTO_TCP MSG_WAITALL SCM_CONNECT SOCK_STREAM SO_RCVLOWAT
1068      SO_RCVTIMEO SO_SNDLOWAT SO_SNDTIMEO TCP_NODELAY */
1069   /* Offset 5 gives the best switch position.  */
1070   switch (name[5]) {
1071   case 'A':
1072     if (memEQ(name, "MSG_WAITALL", 11)) {
1073     /*                    ^            */
1074 #ifdef MSG_WAITALL
1075       *iv_return = MSG_WAITALL;
1076       return PERL_constant_ISIV;
1077 #else
1078       return PERL_constant_NOTDEF;
1079 #endif
1080     }
1081     break;
1082   case 'D':
1083     if (memEQ(name, "SO_SNDLOWAT", 11)) {
1084     /*                    ^            */
1085 #ifdef SO_SNDLOWAT
1086       *iv_return = SO_SNDLOWAT;
1087       return PERL_constant_ISIV;
1088 #else
1089       return PERL_constant_NOTDEF;
1090 #endif
1091     }
1092     if (memEQ(name, "SO_SNDTIMEO", 11)) {
1093     /*                    ^            */
1094 #ifdef SO_SNDTIMEO
1095       *iv_return = SO_SNDTIMEO;
1096       return PERL_constant_ISIV;
1097 #else
1098       return PERL_constant_NOTDEF;
1099 #endif
1100     }
1101     break;
1102   case 'O':
1103     if (memEQ(name, "SCM_CONNECT", 11)) {
1104     /*                    ^            */
1105 #ifdef SCM_CONNECT
1106       *iv_return = SCM_CONNECT;
1107       return PERL_constant_ISIV;
1108 #else
1109       return PERL_constant_NOTDEF;
1110 #endif
1111     }
1112     if (memEQ(name, "TCP_NODELAY", 11)) {
1113     /*                    ^            */
1114 #ifdef TCP_NODELAY
1115       *iv_return = TCP_NODELAY;
1116       return PERL_constant_ISIV;
1117 #else
1118       return PERL_constant_NOTDEF;
1119 #endif
1120     }
1121     break;
1122   case 'R':
1123     if (memEQ(name, "INADDR_NONE", 11)) {
1124     /*                    ^            */
1125 #ifdef INADDR_NONE
1126       {
1127 struct in_addr ip_address; ip_address.s_addr = htonl(INADDR_NONE);
1128         *sv_return =  sv_2mortal(newSVpvn((char *)&ip_address,sizeof ip_address ));
1129         return PERL_constant_ISSV;
1130       }
1131 #else
1132       return PERL_constant_NOTDEF;
1133 #endif
1134     }
1135     break;
1136   case 'S':
1137     if (memEQ(name, "SOCK_STREAM", 11)) {
1138     /*                    ^            */
1139 #ifdef SOCK_STREAM
1140       *iv_return = SOCK_STREAM;
1141       return PERL_constant_ISIV;
1142 #else
1143       return PERL_constant_NOTDEF;
1144 #endif
1145     }
1146     break;
1147   case 'T':
1148     if (memEQ(name, "IPPROTO_TCP", 11)) {
1149     /*                    ^            */
1150 #ifdef IPPROTO_TCP
1151       *iv_return = IPPROTO_TCP;
1152       return PERL_constant_ISIV;
1153 #else
1154       return PERL_constant_NOTDEF;
1155 #endif
1156     }
1157     break;
1158   case 'V':
1159     if (memEQ(name, "SO_RCVLOWAT", 11)) {
1160     /*                    ^            */
1161 #ifdef SO_RCVLOWAT
1162       *iv_return = SO_RCVLOWAT;
1163       return PERL_constant_ISIV;
1164 #else
1165       return PERL_constant_NOTDEF;
1166 #endif
1167     }
1168     if (memEQ(name, "SO_RCVTIMEO", 11)) {
1169     /*                    ^            */
1170 #ifdef SO_RCVTIMEO
1171       *iv_return = SO_RCVTIMEO;
1172       return PERL_constant_ISIV;
1173 #else
1174       return PERL_constant_NOTDEF;
1175 #endif
1176     }
1177     break;
1178   }
1179   return PERL_constant_NOTFOUND;
1180 }
1181
1182 static int
1183 constant_12 (pTHX_ const char *name, IV *iv_return, SV **sv_return) {
1184   /* When generated this function returned values for the list of names given
1185      here.  However, subsequent manual editing may have added or removed some.
1186      AF_APPLETALK MSG_CTLFLAGS MSG_DONTWAIT MSG_ERRQUEUE MSG_NOSIGNAL
1187      PF_APPLETALK SO_BROADCAST SO_DONTROUTE SO_KEEPALIVE SO_OOBINLINE
1188      SO_REUSEADDR SO_REUSEPORT */
1189   /* Offset 10 gives the best switch position.  */
1190   switch (name[10]) {
1191   case 'A':
1192     if (memEQ(name, "MSG_NOSIGNAL", 12)) {
1193     /*                         ^        */
1194 #ifdef MSG_NOSIGNAL
1195       *iv_return = MSG_NOSIGNAL;
1196       return PERL_constant_ISIV;
1197 #else
1198       return PERL_constant_NOTDEF;
1199 #endif
1200     }
1201     break;
1202   case 'D':
1203     if (memEQ(name, "SO_REUSEADDR", 12)) {
1204     /*                         ^        */
1205 #ifdef SO_REUSEADDR
1206       *iv_return = SO_REUSEADDR;
1207       return PERL_constant_ISIV;
1208 #else
1209       return PERL_constant_NOTDEF;
1210 #endif
1211     }
1212     break;
1213   case 'G':
1214     if (memEQ(name, "MSG_CTLFLAGS", 12)) {
1215     /*                         ^        */
1216 #ifdef MSG_CTLFLAGS
1217       *iv_return = MSG_CTLFLAGS;
1218       return PERL_constant_ISIV;
1219 #else
1220       return PERL_constant_NOTDEF;
1221 #endif
1222     }
1223     break;
1224   case 'I':
1225     if (memEQ(name, "MSG_DONTWAIT", 12)) {
1226     /*                         ^        */
1227 #ifdef MSG_DONTWAIT
1228       *iv_return = MSG_DONTWAIT;
1229       return PERL_constant_ISIV;
1230 #else
1231       return PERL_constant_NOTDEF;
1232 #endif
1233     }
1234     break;
1235   case 'L':
1236     if (memEQ(name, "AF_APPLETALK", 12)) {
1237     /*                         ^        */
1238 #ifdef AF_APPLETALK
1239       *iv_return = AF_APPLETALK;
1240       return PERL_constant_ISIV;
1241 #else
1242       return PERL_constant_NOTDEF;
1243 #endif
1244     }
1245     if (memEQ(name, "PF_APPLETALK", 12)) {
1246     /*                         ^        */
1247 #ifdef PF_APPLETALK
1248       *iv_return = PF_APPLETALK;
1249       return PERL_constant_ISIV;
1250 #else
1251       return PERL_constant_NOTDEF;
1252 #endif
1253     }
1254     break;
1255   case 'N':
1256     if (memEQ(name, "SO_OOBINLINE", 12)) {
1257     /*                         ^        */
1258 #ifdef SO_OOBINLINE
1259       *iv_return = SO_OOBINLINE;
1260       return PERL_constant_ISIV;
1261 #else
1262       return PERL_constant_NOTDEF;
1263 #endif
1264     }
1265     break;
1266   case 'R':
1267     if (memEQ(name, "SO_REUSEPORT", 12)) {
1268     /*                         ^        */
1269 #ifdef SO_REUSEPORT
1270       *iv_return = SO_REUSEPORT;
1271       return PERL_constant_ISIV;
1272 #else
1273       return PERL_constant_NOTDEF;
1274 #endif
1275     }
1276     break;
1277   case 'S':
1278     if (memEQ(name, "SO_BROADCAST", 12)) {
1279     /*                         ^        */
1280 #ifdef SO_BROADCAST
1281       *iv_return = SO_BROADCAST;
1282       return PERL_constant_ISIV;
1283 #else
1284       return PERL_constant_NOTDEF;
1285 #endif
1286     }
1287     break;
1288   case 'T':
1289     if (memEQ(name, "SO_DONTROUTE", 12)) {
1290     /*                         ^        */
1291 #ifdef SO_DONTROUTE
1292       *iv_return = SO_DONTROUTE;
1293       return PERL_constant_ISIV;
1294 #else
1295       return PERL_constant_NOTDEF;
1296 #endif
1297     }
1298     break;
1299   case 'U':
1300     if (memEQ(name, "MSG_ERRQUEUE", 12)) {
1301     /*                         ^        */
1302 #ifdef MSG_ERRQUEUE
1303       *iv_return = MSG_ERRQUEUE;
1304       return PERL_constant_ISIV;
1305 #else
1306       return PERL_constant_NOTDEF;
1307 #endif
1308     }
1309     break;
1310   case 'V':
1311     if (memEQ(name, "SO_KEEPALIVE", 12)) {
1312     /*                         ^        */
1313 #ifdef SO_KEEPALIVE
1314       *iv_return = SO_KEEPALIVE;
1315       return PERL_constant_ISIV;
1316 #else
1317       return PERL_constant_NOTDEF;
1318 #endif
1319     }
1320     break;
1321   }
1322   return PERL_constant_NOTFOUND;
1323 }
1324
1325 static int
1326 constant_13 (pTHX_ const char *name, IV *iv_return, SV **sv_return) {
1327   /* When generated this function returned values for the list of names given
1328      here.  However, subsequent manual editing may have added or removed some.
1329      MSG_CTLIGNORE MSG_DONTROUTE MSG_MAXIOVLEN SCM_TIMESTAMP SO_ACCEPTCONN
1330      SO_DONTLINGER TCP_KEEPALIVE */
1331   /* Offset 5 gives the best switch position.  */
1332   switch (name[5]) {
1333   case 'A':
1334     if (memEQ(name, "MSG_MAXIOVLEN", 13)) {
1335     /*                    ^              */
1336 #ifdef MSG_MAXIOVLEN
1337       *iv_return = MSG_MAXIOVLEN;
1338       return PERL_constant_ISIV;
1339 #else
1340       return PERL_constant_NOTDEF;
1341 #endif
1342     }
1343     break;
1344   case 'C':
1345     if (memEQ(name, "SO_ACCEPTCONN", 13)) {
1346     /*                    ^              */
1347 #ifdef SO_ACCEPTCONN
1348       *iv_return = SO_ACCEPTCONN;
1349       return PERL_constant_ISIV;
1350 #else
1351       return PERL_constant_NOTDEF;
1352 #endif
1353     }
1354     break;
1355   case 'E':
1356     if (memEQ(name, "TCP_KEEPALIVE", 13)) {
1357     /*                    ^              */
1358 #ifdef TCP_KEEPALIVE
1359       *iv_return = TCP_KEEPALIVE;
1360       return PERL_constant_ISIV;
1361 #else
1362       return PERL_constant_NOTDEF;
1363 #endif
1364     }
1365     break;
1366   case 'I':
1367     if (memEQ(name, "SCM_TIMESTAMP", 13)) {
1368     /*                    ^              */
1369 #ifdef SCM_TIMESTAMP
1370       *iv_return = SCM_TIMESTAMP;
1371       return PERL_constant_ISIV;
1372 #else
1373       return PERL_constant_NOTDEF;
1374 #endif
1375     }
1376     break;
1377   case 'N':
1378     if (memEQ(name, "SO_DONTLINGER", 13)) {
1379     /*                    ^              */
1380 #ifdef SO_DONTLINGER
1381       *iv_return = SO_DONTLINGER;
1382       return PERL_constant_ISIV;
1383 #else
1384       return PERL_constant_NOTDEF;
1385 #endif
1386     }
1387     break;
1388   case 'O':
1389     if (memEQ(name, "MSG_DONTROUTE", 13)) {
1390     /*                    ^              */
1391 #if defined(MSG_DONTROUTE) || defined(HAS_MSG_DONTROUTE) /* might be an enum */
1392       *iv_return = MSG_DONTROUTE;
1393       return PERL_constant_ISIV;
1394 #else
1395       return PERL_constant_NOTDEF;
1396 #endif
1397     }
1398     break;
1399   case 'T':
1400     if (memEQ(name, "MSG_CTLIGNORE", 13)) {
1401     /*                    ^              */
1402 #ifdef MSG_CTLIGNORE
1403       *iv_return = MSG_CTLIGNORE;
1404       return PERL_constant_ISIV;
1405 #else
1406       return PERL_constant_NOTDEF;
1407 #endif
1408     }
1409     break;
1410   }
1411   return PERL_constant_NOTFOUND;
1412 }
1413
1414 static int
1415 constant (pTHX_ const char *name, STRLEN len, IV *iv_return, SV **sv_return) {
1416   /* Initially switch on the length of the name.  */
1417   /* When generated this function returned values for the list of names given
1418      in this section of perl code.  Rather than manually editing these functions
1419      to add or remove constants, which would result in this comment and section
1420      of code becoming inaccurate, we recommend that you edit this section of
1421      code, and use it to regenerate a new set of constant functions which you
1422      then use to replace the originals.
1423
1424      Regenerate these constant functions by feeding this entire source file to
1425      perl -x
1426
1427 #!../../perl -w
1428 use ExtUtils::Constant qw (constant_types C_constant XS_constant);
1429
1430 my $types = {map {($_, 1)} qw(IV SV)};
1431 my @names = (qw(AF_802 AF_APPLETALK AF_CCITT AF_CHAOS AF_DATAKIT AF_DECnet
1432                AF_DLI AF_ECMA AF_GOSIP AF_HYLINK AF_IMPLINK AF_INET AF_LAT
1433                AF_MAX AF_NBS AF_NIT AF_NS AF_OSI AF_OSINET AF_PUP AF_SNA
1434                AF_UNIX AF_UNSPEC AF_X25 IOV_MAX IPPROTO_TCP MSG_BCAST
1435                MSG_CTLFLAGS MSG_CTLIGNORE MSG_DONTWAIT MSG_EOF MSG_EOR
1436                MSG_ERRQUEUE MSG_FIN MSG_MAXIOVLEN MSG_MCAST MSG_NOSIGNAL
1437                MSG_RST MSG_SYN MSG_TRUNC MSG_URG MSG_WAITALL PF_802
1438                PF_APPLETALK PF_CCITT PF_CHAOS PF_DATAKIT PF_DECnet PF_DLI
1439                PF_ECMA PF_GOSIP PF_HYLINK PF_IMPLINK PF_INET PF_LAT PF_MAX
1440                PF_NBS PF_NIT PF_NS PF_OSI PF_OSINET PF_PUP PF_SNA PF_UNIX
1441                PF_UNSPEC PF_X25 SCM_CONNECT SCM_CREDENTIALS SCM_CREDS
1442                SCM_TIMESTAMP SOCK_DGRAM SOCK_RAW SOCK_RDM SOCK_SEQPACKET
1443                SOCK_STREAM SOL_SOCKET SOMAXCONN SO_ACCEPTCONN SO_BROADCAST
1444                SO_DEBUG SO_DONTLINGER SO_DONTROUTE SO_ERROR SO_KEEPALIVE
1445                SO_LINGER SO_OOBINLINE SO_RCVBUF SO_RCVLOWAT SO_RCVTIMEO
1446                SO_REUSEADDR SO_REUSEPORT SO_SNDBUF SO_SNDLOWAT SO_SNDTIMEO
1447                SO_TYPE SO_USELOOPBACK TCP_KEEPALIVE TCP_MAXRT TCP_MAXSEG
1448                TCP_NODELAY TCP_STDURG UIO_MAXIOV),
1449             {name=>"INADDR_ANY", type=>"SV", value=>"sv_2mortal(newSVpvn((char *)&ip_address,sizeof ip_address ))", pre=>"struct in_addr ip_address; ip_address.s_addr = htonl(INADDR_ANY);"},
1450             {name=>"INADDR_BROADCAST", type=>"SV", value=>"sv_2mortal(newSVpvn((char *)&ip_address,sizeof ip_address ))", pre=>"struct in_addr ip_address; ip_address.s_addr = htonl(INADDR_BROADCAST);"},
1451             {name=>"INADDR_LOOPBACK", type=>"SV", value=>"sv_2mortal(newSVpvn((char *)&ip_address,sizeof ip_address ))", pre=>"struct in_addr ip_address; ip_address.s_addr = htonl(INADDR_LOOPBACK);"},
1452             {name=>"INADDR_NONE", type=>"SV", value=>"sv_2mortal(newSVpvn((char *)&ip_address,sizeof ip_address ))", pre=>"struct in_addr ip_address; ip_address.s_addr = htonl(INADDR_NONE);"},
1453             {name=>"MSG_CTRUNC", type=>"IV", macro=>["#if defined(MSG_CTRUNC) || defined(HAS_MSG_CTRUNC) /" . "* might be an enum *" . "/\n", "#endif\n"]},
1454             {name=>"MSG_DONTROUTE", type=>"IV", macro=>["#if defined(MSG_DONTROUTE) || defined(HAS_MSG_DONTROUTE) /" . "* might be an enum *" . "/\n", "#endif\n"]},
1455             {name=>"MSG_OOB", type=>"IV", macro=>["#if defined(MSG_OOB) || defined(HAS_MSG_OOB) /" . "* might be an enum *" . "/\n", "#endif\n"]},
1456             {name=>"MSG_PEEK", type=>"IV", macro=>["#if defined(MSG_PEEK) || defined(HAS_MSG_PEEK) /" . "* might be an enum *" . "/\n", "#endif\n"]},
1457             {name=>"MSG_PROXY", type=>"IV", macro=>["#if defined(MSG_PROXY) || defined(HAS_MSG_PROXY) /" . "* might be an enum *" . "/\n", "#endif\n"]},
1458             {name=>"SCM_RIGHTS", type=>"IV", macro=>["#if defined(SCM_RIGHTS) || defined(HAS_SCM_RIGHTS) /" . "* might be an enum *" . "/\n", "#endif\n"]},
1459             {name=>"SHUT_RD", type=>"IV", default=>["IV", "0"]},
1460             {name=>"SHUT_RDWR", type=>"IV", default=>["IV", "2"]},
1461             {name=>"SHUT_WR", type=>"IV", default=>["IV", "1"]});
1462
1463 print constant_types(); # macro defs
1464 foreach (C_constant ("Socket", 'constant', 'IV', $types, undef, 3, @names) ) {
1465     print $_, "\n"; # C constant subs
1466 }
1467 print "#### XS Section:\n";
1468 print XS_constant ("Socket", $types);
1469 __END__
1470    */
1471
1472   switch (len) {
1473   case 5:
1474     /* Names all of length 5.  */
1475     /* AF_NS PF_NS */
1476     /* Offset 0 gives the best switch position.  */
1477     switch (name[0]) {
1478     case 'A':
1479       if (memEQ(name, "AF_NS", 5)) {
1480       /*               ^          */
1481 #ifdef AF_NS
1482         *iv_return = AF_NS;
1483         return PERL_constant_ISIV;
1484 #else
1485         return PERL_constant_NOTDEF;
1486 #endif
1487       }
1488       break;
1489     case 'P':
1490       if (memEQ(name, "PF_NS", 5)) {
1491       /*               ^          */
1492 #ifdef PF_NS
1493         *iv_return = PF_NS;
1494         return PERL_constant_ISIV;
1495 #else
1496         return PERL_constant_NOTDEF;
1497 #endif
1498       }
1499       break;
1500     }
1501     break;
1502   case 6:
1503     return constant_6 (aTHX_ name, iv_return, sv_return);
1504     break;
1505   case 7:
1506     return constant_7 (aTHX_ name, iv_return, sv_return);
1507     break;
1508   case 8:
1509     return constant_8 (aTHX_ name, iv_return, sv_return);
1510     break;
1511   case 9:
1512     return constant_9 (aTHX_ name, iv_return, sv_return);
1513     break;
1514   case 10:
1515     return constant_10 (aTHX_ name, iv_return, sv_return);
1516     break;
1517   case 11:
1518     return constant_11 (aTHX_ name, iv_return, sv_return);
1519     break;
1520   case 12:
1521     return constant_12 (aTHX_ name, iv_return, sv_return);
1522     break;
1523   case 13:
1524     return constant_13 (aTHX_ name, iv_return, sv_return);
1525     break;
1526   case 14:
1527     /* Names all of length 14.  */
1528     /* SOCK_SEQPACKET SO_USELOOPBACK */
1529     /* Offset 8 gives the best switch position.  */
1530     switch (name[8]) {
1531     case 'O':
1532       if (memEQ(name, "SO_USELOOPBACK", 14)) {
1533       /*                       ^            */
1534 #ifdef SO_USELOOPBACK
1535         *iv_return = SO_USELOOPBACK;
1536         return PERL_constant_ISIV;
1537 #else
1538         return PERL_constant_NOTDEF;
1539 #endif
1540       }
1541       break;
1542     case 'P':
1543       if (memEQ(name, "SOCK_SEQPACKET", 14)) {
1544       /*                       ^            */
1545 #ifdef SOCK_SEQPACKET
1546         *iv_return = SOCK_SEQPACKET;
1547         return PERL_constant_ISIV;
1548 #else
1549         return PERL_constant_NOTDEF;
1550 #endif
1551       }
1552       break;
1553     }
1554     break;
1555   case 15:
1556     /* Names all of length 15.  */
1557     /* INADDR_LOOPBACK SCM_CREDENTIALS */
1558     /* Offset 4 gives the best switch position.  */
1559     switch (name[4]) {
1560     case 'C':
1561       if (memEQ(name, "SCM_CREDENTIALS", 15)) {
1562       /*                   ^                 */
1563 #ifdef SCM_CREDENTIALS
1564         *iv_return = SCM_CREDENTIALS;
1565         return PERL_constant_ISIV;
1566 #else
1567         return PERL_constant_NOTDEF;
1568 #endif
1569       }
1570       break;
1571     case 'D':
1572       if (memEQ(name, "INADDR_LOOPBACK", 15)) {
1573       /*                   ^                 */
1574 #ifdef INADDR_LOOPBACK
1575         {
1576 struct in_addr ip_address; ip_address.s_addr = htonl(INADDR_LOOPBACK);
1577           *sv_return =  sv_2mortal(newSVpvn((char *)&ip_address,sizeof ip_address ));
1578           return PERL_constant_ISSV;
1579         }
1580 #else
1581         return PERL_constant_NOTDEF;
1582 #endif
1583       }
1584       break;
1585     }
1586     break;
1587   case 16:
1588     if (memEQ(name, "INADDR_BROADCAST", 16)) {
1589 #ifdef INADDR_BROADCAST
1590       {
1591 struct in_addr ip_address; ip_address.s_addr = htonl(INADDR_BROADCAST);
1592         *sv_return =  sv_2mortal(newSVpvn((char *)&ip_address,sizeof ip_address ));
1593         return PERL_constant_ISSV;
1594       }
1595 #else
1596       return PERL_constant_NOTDEF;
1597 #endif
1598     }
1599     break;
1600   }
1601   return PERL_constant_NOTFOUND;
1602 }
1603
1604
1605 MODULE = Socket         PACKAGE = Socket
1606
1607 void
1608 constant(sv)
1609     PREINIT:
1610         dXSTARG;
1611         STRLEN          len;
1612         int             type;
1613         IV              iv;
1614         /* NV           nv;     Uncomment this if you need to return NVs */
1615         /* const char   *pv;    Uncomment this if you need to return PVs */
1616     INPUT:
1617         SV *            sv;
1618         const char *    s = SvPV(sv, len);
1619     PPCODE:
1620         /* Change this to constant(s, len, &iv, &nv);
1621            if you need to return both NVs and IVs */
1622         type = constant(aTHX_ s, len, &iv, &sv);
1623       /* Return 1 or 2 items. First is error message, or undef if no error.
1624            Second, if present, is found value */
1625         switch (type) {
1626         case PERL_constant_NOTFOUND:
1627           sv = sv_2mortal(newSVpvf("%s is not a valid Socket macro", s));
1628           PUSHs(sv);
1629           break;
1630         case PERL_constant_NOTDEF:
1631           sv = sv_2mortal(newSVpvf(
1632             "Your vendor has not defined Socket macro %s, used", s));
1633           PUSHs(sv);
1634           break;
1635         case PERL_constant_ISIV:
1636           EXTEND(SP, 1);
1637           PUSHs(&PL_sv_undef);
1638           PUSHi(iv);
1639           break;
1640         case PERL_constant_ISSV:
1641           EXTEND(SP, 1);
1642           PUSHs(&PL_sv_undef);
1643           PUSHs(sv);
1644           break;
1645         /* Uncomment this if you need to return UVs
1646         case PERL_constant_ISUV:
1647           EXTEND(SP, 1);
1648           PUSHs(&PL_sv_undef);
1649           PUSHu((UV)iv);
1650           break; */
1651         default:
1652           sv = sv_2mortal(newSVpvf(
1653             "Unexpected return type %d while processing Socket macro %s, used",
1654                type, s));
1655           PUSHs(sv);
1656         }
1657
1658 void
1659 inet_aton(host)
1660         char *  host
1661         CODE:
1662         {
1663         struct in_addr ip_address;
1664         struct hostent * phe;
1665         int ok = inet_aton(host, &ip_address);
1666
1667         if (!ok && (phe = gethostbyname(host))) {
1668                 Copy( phe->h_addr, &ip_address, phe->h_length, char );
1669                 ok = 1;
1670         }
1671
1672         ST(0) = sv_newmortal();
1673         if (ok) {
1674                 sv_setpvn( ST(0), (char *)&ip_address, sizeof ip_address );
1675         }
1676         }
1677
1678 void
1679 inet_ntoa(ip_address_sv)
1680         SV *    ip_address_sv
1681         CODE:
1682         {
1683         STRLEN addrlen;
1684         struct in_addr addr;
1685         char * addr_str;
1686         char * ip_address = SvPV(ip_address_sv,addrlen);
1687         if (addrlen != sizeof(addr)) {
1688             croak("Bad arg length for %s, length is %d, should be %d",
1689                         "Socket::inet_ntoa",
1690                         addrlen, sizeof(addr));
1691         }
1692
1693         Copy( ip_address, &addr, sizeof addr, char );
1694         addr_str = inet_ntoa(addr);
1695
1696         ST(0) = sv_2mortal(newSVpvn(addr_str, strlen(addr_str)));
1697         }
1698
1699 void
1700 pack_sockaddr_un(pathname)
1701         char *  pathname
1702         CODE:
1703         {
1704 #ifdef I_SYS_UN
1705         struct sockaddr_un sun_ad; /* fear using sun */
1706         STRLEN len;
1707
1708         Zero( &sun_ad, sizeof sun_ad, char );
1709         sun_ad.sun_family = AF_UNIX;
1710         len = strlen(pathname);
1711         if (len > sizeof(sun_ad.sun_path))
1712             len = sizeof(sun_ad.sun_path);
1713 #  ifdef OS2    /* Name should start with \socket\ and contain backslashes! */
1714         {
1715             int off;
1716             char *s, *e;
1717
1718             if (pathname[0] != '/' && pathname[0] != '\\')
1719                 croak("Relative UNIX domain socket name '%s' unsupported", pathname);
1720             else if (len < 8
1721                      || pathname[7] != '/' && pathname[7] != '\\'
1722                      || !strnicmp(pathname + 1, "socket", 6))
1723                 off = 7;
1724             else
1725                 off = 0;                /* Preserve names starting with \socket\ */
1726             Copy( "\\socket", sun_ad.sun_path, off, char);
1727             Copy( pathname, sun_ad.sun_path + off, len, char );
1728
1729             s = sun_ad.sun_path + off - 1;
1730             e = s + len + 1;
1731             while (++s < e)
1732                 if (*s = '/')
1733                     *s = '\\';
1734         }
1735 #  else /* !( defined OS2 ) */
1736         Copy( pathname, sun_ad.sun_path, len, char );
1737 #  endif
1738         if (0) not_here("dummy");
1739         ST(0) = sv_2mortal(newSVpvn((char *)&sun_ad, sizeof sun_ad));
1740 #else
1741         ST(0) = (SV *) not_here("pack_sockaddr_un");
1742 #endif
1743
1744         }
1745
1746 void
1747 unpack_sockaddr_un(sun_sv)
1748         SV *    sun_sv
1749         CODE:
1750         {
1751 #ifdef I_SYS_UN
1752         struct sockaddr_un addr;
1753         STRLEN sockaddrlen;
1754         char * sun_ad = SvPV(sun_sv,sockaddrlen);
1755         char * e;
1756 #   ifndef __linux__
1757         /* On Linux sockaddrlen on sockets returned by accept, recvfrom,
1758            getpeername and getsockname is not equal to sizeof(addr). */
1759         if (sockaddrlen != sizeof(addr)) {
1760             croak("Bad arg length for %s, length is %d, should be %d",
1761                         "Socket::unpack_sockaddr_un",
1762                         sockaddrlen, sizeof(addr));
1763         }
1764 #   endif
1765
1766         Copy( sun_ad, &addr, sizeof addr, char );
1767
1768         if ( addr.sun_family != AF_UNIX ) {
1769             croak("Bad address family for %s, got %d, should be %d",
1770                         "Socket::unpack_sockaddr_un",
1771                         addr.sun_family,
1772                         AF_UNIX);
1773         }
1774         e = addr.sun_path;
1775         while (*e && e < addr.sun_path + sizeof addr.sun_path)
1776             ++e;
1777         ST(0) = sv_2mortal(newSVpvn(addr.sun_path, e - addr.sun_path));
1778 #else
1779         ST(0) = (SV *) not_here("unpack_sockaddr_un");
1780 #endif
1781         }
1782
1783 void
1784 pack_sockaddr_in(port,ip_address)
1785         unsigned short  port
1786         char *  ip_address
1787         CODE:
1788         {
1789         struct sockaddr_in sin;
1790
1791         Zero( &sin, sizeof sin, char );
1792         sin.sin_family = AF_INET;
1793         sin.sin_port = htons(port);
1794         Copy( ip_address, &sin.sin_addr, sizeof sin.sin_addr, char );
1795
1796         ST(0) = sv_2mortal(newSVpvn((char *)&sin, sizeof sin));
1797         }
1798
1799 void
1800 unpack_sockaddr_in(sin_sv)
1801         SV *    sin_sv
1802         PPCODE:
1803         {
1804         STRLEN sockaddrlen;
1805         struct sockaddr_in addr;
1806         unsigned short  port;
1807         struct in_addr  ip_address;
1808         char *  sin = SvPV(sin_sv,sockaddrlen);
1809         if (sockaddrlen != sizeof(addr)) {
1810             croak("Bad arg length for %s, length is %d, should be %d",
1811                         "Socket::unpack_sockaddr_in",
1812                         sockaddrlen, sizeof(addr));
1813         }
1814         Copy( sin, &addr,sizeof addr, char );
1815         if ( addr.sin_family != AF_INET ) {
1816             croak("Bad address family for %s, got %d, should be %d",
1817                         "Socket::unpack_sockaddr_in",
1818                         addr.sin_family,
1819                         AF_INET);
1820         }
1821         port = ntohs(addr.sin_port);
1822         ip_address = addr.sin_addr;
1823
1824         EXTEND(SP, 2);
1825         PUSHs(sv_2mortal(newSViv((IV) port)));
1826         PUSHs(sv_2mortal(newSVpvn((char *)&ip_address,sizeof ip_address)));
1827         }