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