net-tools/patches/net-tools-1.60-sctp.patch

   1 --- net-tools-1.60/statistics.c.sctp    2006-04-13 10:06:45.000000000 -0400
   2 +++ net-tools-1.60/statistics.c 2006-04-13 10:06:45.000000000 -0400
   3 @@ -20,7 +20,7 @@
   4  #define UFWARN(x)
   5  #endif
   6
   7 -int print_static,f_raw,f_tcp,f_udp,f_unknown = 1;
   8 +int print_static,f_raw,f_tcp,f_udp,f_sctp,f_unknown = 1;
   9
  10  enum State {
  11      number = 0, opt_number, i_forward, i_inp_icmp, i_outp_icmp, i_rto_alg,
  12 @@ -225,6 +225,27 @@
  13       { "TCPLoss", N_("%u TCP data loss events") },
  14  };
  15
  16 +struct entry Sctptab[] =
  17 +{
  18 +    {"SctpCurrEstab", N_("%u Current Associations"), number},
  19 +    {"SctpActiveEstabs", N_("%u Active Associations"), number},
  20 +    {"SctpPassiveEstabs", N_("%u Passive Associations"), number},
  21 +    {"SctpAborteds", N_("%u Number of Aborteds "), number},
  22 +    {"SctpShutdowns", N_("%u Number of Graceful Terminations"), number},
  23 +    {"SctpOutOfBlues", N_("%u Number of Out of Blue packets"), number},
  24 +    {"SctpChecksumErrors", N_("%u Number of Packets with invalid Checksum"), number},
  25 +    {"SctpOutCtrlChunks", N_("%u Number of control chunks sent"), number},
  26 +    {"SctpOutOrderChunks", N_("%u Number of ordered chunks sent"), number},
  27 +    {"SctpOutUnorderChunks", N_("%u Number of Unordered chunks sent"), number},
  28 +    {"SctpInCtrlChunks", N_("%u Number of control chunks received"), number},
  29 +    {"SctpInOrderChunks", N_("%u Number of ordered chunks received"), number},
  30 +    {"SctpInUnorderChunks", N_("%u Number of Unordered chunks received"), number},
  31 +    {"SctpFragUsrMsgs", N_("%u Number of messages fragmented"), number},
  32 +    {"SctpReasmUsrMsgs", N_("%u Number of messages reassembled "), number},
  33 +    {"SctpOutSCTPPacks", N_("%u Number of SCTP packets sent"), number},
  34 +    {"SctpInSCTPPacks", N_("%u Number of SCTP packets received"), number},
  35 +};
  36 +
  37  struct tabtab {
  38      char *title;
  39      struct entry *tab;
  40 @@ -238,6 +259,7 @@
  41      {"Icmp", Icmptab, sizeof(Icmptab), &f_raw},
  42      {"Tcp", Tcptab, sizeof(Tcptab), &f_tcp},
  43      {"Udp", Udptab, sizeof(Udptab), &f_udp},
  44 +    {"Sctp", Sctptab, sizeof(Sctptab), &f_sctp},
  45      {"TcpExt", Tcpexttab, sizeof(Tcpexttab), &f_tcp},
  46      {NULL}
  47  };
  48 @@ -385,12 +407,39 @@
  49    return;
  50  }
  51
  52 +/* Process a file with name-value lines (like /proc/net/sctp/snmp) */
  53 +void process_fd2(FILE *f, const char *filename)
  54 +{
  55 +    char buf1[1024];
  56 +    char *sp;
  57 +    struct tabtab *tab;
  58 +
  59 +    tab = newtable(snmptabs, "Sctp");
  60 +
  61 +    while (fgets(buf1, sizeof buf1, f)) {
  62 +       sp = buf1 + strcspn(buf1, " \t\n");
  63 +       if (!sp)
  64 +           goto formaterr;
  65 +       *sp = '\0';
  66 +       sp++;
  67 +
  68 +       sp += strspn(sp, " \t\n");
  69
  70 -int parsesnmp(int flag_raw, int flag_tcp, int flag_udp)
  71 +       if (*sp != '\0' && *(tab->flag))
  72 +           printval(tab, buf1, strtoul(sp, 0, 10));
  73 +    }
  74 +  return;
  75 +
  76 +formaterr:
  77 +  fprintf(stderr,_("error parsing %s\n"), filename);
  78 +  return;
  79 +}
  80 +
  81 +int parsesnmp(int flag_raw, int flag_tcp, int flag_udp, int flag_sctp)
  82  {
  83      FILE *f;
  84
  85 -    f_raw = flag_raw; f_tcp = flag_tcp; f_udp = flag_udp;
  86 +    f_raw = flag_raw; f_tcp = flag_tcp; f_udp = flag_udp; f_sctp = flag_sctp;
  87
  88      f = fopen("/proc/net/snmp", "r");
  89      if (!f) {
  90 @@ -418,6 +467,16 @@
  91
  92          fclose(f);
  93      }
  94 +
  95 +    f = fopen("/proc/net/sctp/snmp", "r");
  96 +    if (f) {
  97 +       process_fd2(f,"/proc/net/sctp/snmp");
  98 +       if (ferror(f))
  99 +           perror("/proc/net/sctp/snmp");
 100 +
 101 +       fclose(f);
 102 +    }
 103 +
 104      return(0);
 105  }
 106
 107 --- net-tools-1.60/netstat.c.sctp       2006-04-13 10:06:45.000000000 -0400
 108 +++ net-tools-1.60/netstat.c    2006-04-13 10:10:23.000000000 -0400
 109 @@ -58,6 +58,7 @@
 110   *
 111   *990420 {1.38} Tuan Hoang              removed a useless assignment from igmp_do_one()
 112   *20010404 {1.39} Arnaldo Carvalho de Melo - use setlocale
 113 + *20050516 {1.40} Ivan Skytte Joergensen:Added SCTP support
 114   *
 115   *              This program is free software; you can redistribute it
 116   *              and/or  modify it under  the terms of  the GNU General
 117 @@ -108,7 +109,7 @@
 118  #endif
 119
 120  /* prototypes for statistics.c */
 121 -int parsesnmp(int, int, int);
 122 +int parsesnmp(int, int, int, int);
 123  void inittab(void);
 124
 125  typedef enum {
 126 @@ -119,6 +120,29 @@
 127      SS_DISCONNECTING           /* in process of disconnecting  */
 128  } socket_state;
 129
 130 +
 131 +#define SCTP_NSTATES  9         /* The number of states in array*/
 132 +
 133 +static const char *sctp_state[] = {
 134 +    N_("EMPTY"),
 135 +    N_("CLOSED"),
 136 +    N_("COOKIE_WAIT"),
 137 +    N_("COOKIE_ECHOED"),
 138 +    N_("ESTABLISHED"),
 139 +    N_("SHUTDOWN_PENDING"),
 140 +    N_("SHUTDOWN_SENT"),
 141 +    N_("SHUTDOWN_RECEIVED"),
 142 +    N_("SHUTDOWN_ACK_SENT")
 143 +};
 144 +
 145 +#define SCTP_NTYPES 3           /* The number of types in array */
 146 +
 147 +static const char *sctp_type[] = {
 148 +    N_("udp"),
 149 +    N_("udp-high-bw"),
 150 +    N_("tcp")
 151 +};
 152 +
 153  #define SO_ACCEPTCON    (1<<16)        /* performed a listen           */
 154  #define SO_WAITDATA     (1<<17)        /* wait data to read            */
 155  #define SO_NOSPACE      (1<<18)        /* no space to write            */
 156 @@ -150,6 +174,7 @@
 157  int flag_raw = 0;
 158  int flag_tcp = 0;
 159  int flag_udp = 0;
 160 +int flag_sctp= 0;
 161  int flag_igmp= 0;
 162  int flag_rom = 0;
 163  int flag_exp = 1;
 164 @@ -1189,6 +1214,365 @@
 165                udp_do_one);
 166  }
 167
 168 +static const char *sctp_socket_type_str(int type) {
 169 +    if(type>=0 && type<SCTP_NTYPES)
 170 +       return sctp_type[type];
 171 +    else {
 172 +       static char type_str_buf[64];
 173 +       sprintf(type_str_buf,"UNKNOWN(%d)",type);
 174 +       return type_str_buf;
 175 +    }
 176 +}
 177 +
 178 +static const char *sctp_state_str(int state)
 179 +{
 180 +    if(state>=0 && state<SCTP_NSTATES)
 181 +       return sctp_state[state];
 182 +    else {
 183 +       static char state_str_buf[64];
 184 +       sprintf(state_str_buf,"UNKNOWN(%d)",state);
 185 +       return state_str_buf;
 186 +    }
 187 +}
 188 +
 189 +static const char *sctp_socket_state_str(int state)
 190 +{
 191 +    if(state>=0 && state<=10)
 192 +        return tcp_state[state];
 193 +    else {
 194 +       static char state_str_buf[64];
 195 +       sprintf(state_str_buf,"UNKNOWN(%d)",state);
 196 +       return state_str_buf;
 197 +    }
 198 +}
 199 +
 200 +static struct aftype *process_sctp_addr_str(const char *addr_str, struct sockaddr *sa)
 201 +{
 202 +    if (strchr(addr_str,':')) {
 203 +#if HAVE_AFINET6
 204 +       extern struct aftype inet6_aftype;
 205 +       /* Demangle what the kernel gives us */
 206 +       struct in6_addr in6;
 207 +       char addr6_str[INET6_ADDRSTRLEN];
 208 +       unsigned u0,u1,u2,u3,u4,u5,u6,u7;
 209 +       sscanf(addr_str, "%04X:%04X:%04X:%04X:%04X:%04X:%04X:%04X",
 210 +              &u0, &u1, &u2, &u3, &u4, &u5, &u6, &u7);
 211 +       in6.s6_addr16[0] = htons(u0);
 212 +       in6.s6_addr16[1] = htons(u1);
 213 +       in6.s6_addr16[2] = htons(u2);
 214 +       in6.s6_addr16[3] = htons(u3);
 215 +       in6.s6_addr16[4] = htons(u4);
 216 +       in6.s6_addr16[5] = htons(u5);
 217 +       in6.s6_addr16[6] = htons(u6);
 218 +       in6.s6_addr16[7] = htons(u7);
 219 +
 220 +       inet_ntop(AF_INET6, &in6, addr6_str, sizeof(addr6_str));
 221 +       inet6_aftype.input(1, addr6_str, sa);
 222 +       sa->sa_family = AF_INET6;
 223 +#endif
 224 +    } else {
 225 +       ((struct sockaddr_in*)sa)->sin_addr.s_addr = inet_addr(addr_str);
 226 +       sa->sa_family = AF_INET;
 227 +    }
 228 +    return get_afntype(sa->sa_family);
 229 +}
 230 +
 231 +static void sctp_eps_do_one(int lnr, char *line)
 232 +{
 233 +    char buffer[1024];
 234 +    int type, state, port;
 235 +    int uid;
 236 +    unsigned long inode;
 237 +
 238 +    struct aftype *ap;
 239 +#if HAVE_AFINET6
 240 +    struct sockaddr_in6 localaddr;
 241 +#else
 242 +    struct sockaddr_in localaddr;
 243 +#endif
 244 +    const char *sty_str;
 245 +    const char *sst_str;
 246 +    const char *lport_str;
 247 +    const char *uid_str;
 248 +    const char *inode_str;
 249 +    const char *pladdr_str;
 250 +    char *laddrs_str;
 251 +
 252 +    if(lnr == 0) {
 253 +       /* ENDPT     SOCK   STY SST HBKT LPORT   uid inode pladdr LADDRS*/
 254 +       return;
 255 +    }
 256 +
 257 +    strtok(line," \t\n"); /*skip ptr*/
 258 +    strtok(0," \t\n");    /*skip ptr*/
 259 +    sty_str = strtok(0," \t\n");
 260 +    sst_str = strtok(0," \t\n");
 261 +    strtok(0," \t\n"); /*skip hash bucket*/
 262 +    lport_str=strtok(0," \t\n");
 263 +    uid_str = strtok(0," \t\n");
 264 +    inode_str = strtok(0," \t\n");
 265 +    pladdr_str = strtok(0," \t\n");
 266 +    laddrs_str=strtok(0,"\t\n");
 267 +
 268 +    type = atoi(sty_str);
 269 +    state = atoi(sst_str);
 270 +    port = atoi(lport_str);
 271 +    uid = atoi(uid_str);
 272 +    inode = strtoul(inode_str,0,0);
 273 +
 274 +    if(flag_sctp<=1) {
 275 +       /* only print the primary address */
 276 +       char local_addr[64];
 277 +       char local_port[16];
 278 +
 279 +       ap = process_sctp_addr_str(pladdr_str, (struct sockaddr*)&localaddr);
 280 +       if(ap)
 281 +           safe_strncpy(local_addr,
 282 +                        ap->sprint((struct sockaddr *) &localaddr, flag_not),
 283 +                        sizeof(local_addr));
 284 +       else
 285 +           sprintf(local_addr,_("unsupported address family %d"), ((struct sockaddr*)&localaddr)->sa_family);
 286 +
 287 +       snprintf(local_port, sizeof(local_port), "%s",
 288 +                get_sname(htons(port), "sctp",
 289 +                          flag_not & FLAG_NUM_PORT));
 290 +
 291 +       printf("sctp                ");
 292 +       sprintf(buffer,"%s:%s", local_addr, local_port);
 293 +       printf("%-47s", buffer);
 294 +       printf(" %-12s", sctp_socket_state_str(state));
 295 +    } else {
 296 +       /*print all addresses*/
 297 +       const char *this_local_addr;
 298 +       int first=1;
 299 +       char local_port[16];
 300 +       snprintf(local_port, sizeof(local_port), "%s",
 301 +                get_sname(htons(port), "sctp",
 302 +                          flag_not & FLAG_NUM_PORT));
 303 +       for(this_local_addr=strtok(laddrs_str," \t\n");
 304 +           this_local_addr;
 305 +           this_local_addr=strtok(0," \t\n"))
 306 +       {
 307 +           char local_addr[64];
 308 +           ap = process_sctp_addr_str(this_local_addr, (struct sockaddr*)&localaddr);
 309 +           if(ap)
 310 +               safe_strncpy(local_addr,
 311 +                            ap->sprint((struct sockaddr *) &localaddr, flag_not),
 312 +                            sizeof(local_addr));
 313 +           else
 314 +               sprintf(local_addr,_("unsupported address family %d"), ((struct sockaddr*)&localaddr)->sa_family);
 315 +
 316 +           if(!first) printf("\n");
 317 +           if(first)
 318 +               printf("sctp                ");
 319 +           else
 320 +               printf("                    ");
 321 +           sprintf(buffer,"%s:%s", local_addr, local_port);
 322 +           printf("%-47s", buffer);
 323 +           printf(" %-12s", first?sctp_socket_state_str(state):"");
 324 +           first = 0;
 325 +       }
 326 +    }
 327 +
 328 +    finish_this_one(uid,inode,"");
 329 +}
 330 +
 331 +static void sctp_assoc_do_one(int lnr, char *line)
 332 +{
 333 +    char buffer[1024];
 334 +    int type, state, state2, lport,rport;
 335 +    int uid;
 336 +    unsigned rxqueue,txqueue;
 337 +    unsigned long inode;
 338 +
 339 +    struct aftype *ap;
 340 +#if HAVE_AFINET6
 341 +    struct sockaddr_in6 localaddr,remoteaddr;
 342 +#else
 343 +    struct sockaddr_in localaddr,remoteaddr;
 344 +#endif
 345 +    const char *sty_str;
 346 +    const char *sst_str;
 347 +    const char *st_str;
 348 +    const char *txqueue_str;
 349 +    const char *rxqueue_str;
 350 +    const char *lport_str,*rport_str;
 351 +    const char *uid_str;
 352 +    const char *inode_str;
 353 +    const char *pladdr_str;
 354 +    char *laddrs_str;
 355 +    const char *praddr_str;
 356 +    char *raddrs_str;
 357 +
 358 +    if(lnr == 0) {
 359 +       /* ASSOC     SOCK   STY SST ST HBKT tx_queue rx_queue uid inode LPORT RPORT pladdr praddr LADDRS <-> RADDRS*/
 360 +       return;
 361 +    }
 362 +
 363 +    strtok(line," \t\n"); /*skip ptr*/
 364 +    strtok(0," \t\n");    /*skip ptr*/
 365 +    sty_str = strtok(0," \t\n");
 366 +    sst_str = strtok(0," \t\n");
 367 +    st_str = strtok(0," \t\n");
 368 +    strtok(0," \t\n"); /*skip hash bucket*/
 369 +    txqueue_str =  strtok(0," \t\n");
 370 +    rxqueue_str =  strtok(0," \t\n");
 371 +    uid_str = strtok(0," \t\n");
 372 +    inode_str = strtok(0," \t\n");
 373 +    lport_str=strtok(0," \t\n");
 374 +    rport_str=strtok(0," \t\n");
 375 +    pladdr_str = strtok(0," \t\n");
 376 +    praddr_str = strtok(0," \t\n");
 377 +    laddrs_str=strtok(0,"<->\t\n");
 378 +    raddrs_str=strtok(0,"<->\t\n");
 379 +
 380 +    type = atoi(sty_str);
 381 +    state = atoi(sst_str);
 382 +    state2 = atoi(st_str);
 383 +    txqueue = atoi(txqueue_str);
 384 +    rxqueue = atoi(rxqueue_str);
 385 +    uid = atoi(uid_str);
 386 +    inode = strtoul(inode_str,0,0);
 387 +    lport = atoi(lport_str);
 388 +    rport = atoi(rport_str);
 389 +
 390 +    if(flag_sctp<=1) {
 391 +       /* only print the primary addresses */
 392 +       char local_addr[64];
 393 +       char local_port[16];
 394 +       char remote_addr[64];
 395 +       char remote_port[16];
 396 +
 397 +       ap = process_sctp_addr_str(pladdr_str, (struct sockaddr*)&localaddr);
 398 +       if(ap)
 399 +           safe_strncpy(local_addr,
 400 +                        ap->sprint((struct sockaddr *) &localaddr, flag_not),
 401 +                        sizeof(local_addr));
 402 +       else
 403 +           sprintf(local_addr,_("unsupported address family %d"), ((struct sockaddr*)&localaddr)->sa_family);
 404 +
 405 +       snprintf(local_port, sizeof(local_port), "%s",
 406 +                get_sname(htons(lport), "sctp",
 407 +                          flag_not & FLAG_NUM_PORT));
 408 +
 409 +       ap = process_sctp_addr_str(praddr_str, (struct sockaddr*)&remoteaddr);
 410 +       if(ap)
 411 +           safe_strncpy(remote_addr,
 412 +                        ap->sprint((struct sockaddr *) &remoteaddr, flag_not),
 413 +                        sizeof(remote_addr));
 414 +       else
 415 +           sprintf(remote_addr,_("unsupported address family %d"), ((struct sockaddr*)&remoteaddr)->sa_family);
 416 +
 417 +       snprintf(remote_port, sizeof(remote_port), "%s",
 418 +                get_sname(htons(rport), "sctp",
 419 +                          flag_not & FLAG_NUM_PORT));
 420 +
 421 +       printf("sctp");
 422 +       printf("  %6u %6u ", rxqueue, txqueue);
 423 +       sprintf(buffer,"%s:%s", local_addr, local_port);
 424 +       printf("%-23s", buffer);
 425 +       printf(" ");
 426 +       sprintf(buffer,"%s:%s", remote_addr, remote_port);
 427 +       printf("%-23s", buffer);
 428 +       printf(" %-12s", sctp_socket_state_str(state));
 429 +    } else {
 430 +       /*print all addresses*/
 431 +       const char *this_local_addr;
 432 +       const char *this_remote_addr;
 433 +       char *ss1,*ss2;
 434 +       int first=1;
 435 +       char local_port[16];
 436 +       char remote_port[16];
 437 +       snprintf(local_port, sizeof(local_port), "%s",
 438 +                get_sname(htons(lport), "sctp",
 439 +                          flag_not & FLAG_NUM_PORT));
 440 +       snprintf(remote_port, sizeof(remote_port), "%s",
 441 +                get_sname(htons(rport), "sctp",
 442 +                          flag_not & FLAG_NUM_PORT));
 443 +
 444 +       this_local_addr=strtok_r(laddrs_str," \t\n",&ss1);
 445 +       this_remote_addr=strtok_r(raddrs_str," \t\n",&ss2);
 446 +       while(this_local_addr || this_remote_addr) {
 447 +           char local_addr[64];
 448 +           char remote_addr[64];
 449 +           if(this_local_addr) {
 450 +               ap = process_sctp_addr_str(this_local_addr, (struct sockaddr*)&localaddr);
 451 +               if(ap)
 452 +                   safe_strncpy(local_addr,
 453 +                                ap->sprint((struct sockaddr *) &localaddr, flag_not),
 454 +                                sizeof(local_addr));
 455 +               else
 456 +                   sprintf(local_addr,_("unsupported address family %d"), ((struct sockaddr*)&localaddr)->sa_family);
 457 +           }
 458 +           if(this_remote_addr) {
 459 +               ap = process_sctp_addr_str(this_remote_addr, (struct sockaddr*)&remoteaddr);
 460 +               if(ap)
 461 +                   safe_strncpy(remote_addr,
 462 +                                ap->sprint((struct sockaddr *) &remoteaddr, flag_not),
 463 +                                sizeof(remote_addr));
 464 +               else
 465 +                   sprintf(remote_addr,_("unsupported address family %d"), ((struct sockaddr*)&remoteaddr)->sa_family);
 466 +           }
 467 +
 468 +           if(!first) printf("\n");
 469 +           if(first)
 470 +               printf("sctp  %6u %6u ", rxqueue, txqueue);
 471 +           else
 472 +               printf("                    ");
 473 +           if(this_local_addr) {
 474 +               if(first)
 475 +                   sprintf(buffer,"%s:%s", local_addr, local_port);
 476 +               else
 477 +                   sprintf(buffer,"%s", local_addr);
 478 +               printf("%-23s", buffer);
 479 +           } else
 480 +               printf("%-23s", "");
 481 +           printf(" ");
 482 +           if(this_remote_addr) {
 483 +               if(first)
 484 +                   sprintf(buffer,"%s:%s", remote_addr, remote_port);
 485 +               else
 486 +                   sprintf(buffer,"%s", remote_addr);
 487 +               printf("%-23s", buffer);
 488 +           } else
 489 +               printf("%-23s", "");
 490 +
 491 +           printf(" %-12s", first?sctp_socket_state_str(state):"");
 492 +
 493 +           first = 0;
 494 +           this_local_addr=strtok_r(0," \t\n",&ss1);
 495 +           this_remote_addr=strtok_r(0," \t\n",&ss2);
 496 +       }
 497 +    }
 498 +
 499 +    finish_this_one(uid,inode,"");
 500 +}
 501 +
 502 +static int sctp_info_eps(void)
 503 +{
 504 +#if !defined(_PATH_PROCNET_SCTP_EPS)
 505 +#define        _PATH_PROCNET_SCTP_EPS  "/proc/net/sctp/eps"
 506 +#endif
 507 +    INFO_GUTS(_PATH_PROCNET_SCTP_EPS, "AF INET (sctp)",
 508 +              sctp_eps_do_one);
 509 +}
 510 +
 511 +static int sctp_info_assocs(void)
 512 +{
 513 +#if !defined(_PATH_PROCNET_SCTP_ASSOCS)
 514 +#define        _PATH_PROCNET_SCTP_ASSOCS       "/proc/net/sctp/assocs"
 515 +#endif
 516 +    INFO_GUTS(_PATH_PROCNET_SCTP_ASSOCS, "AF INET (sctp)",
 517 +              sctp_assoc_do_one);
 518 +}
 519 +
 520 +static int sctp_info(void)
 521 +{
 522 +    if(flag_all)
 523 +       sctp_info_eps();
 524 +    return sctp_info_assocs();
 525 +}
 526 +
 527  static void raw_do_one(int lnr, const char *line)
 528  {
 529      char buffer[8192], local_addr[64], rem_addr[64];
 530 @@ -1742,7 +2126,7 @@
 531      fprintf(stderr, _("        -Z, --context              display SELinux security context for sockets\n\n"));
 532
 533      fprintf(stderr, _("  <Iface>: Name of interface to monitor/list.\n"));
 534 -    fprintf(stderr, _("  <Socket>={-t|--tcp} {-u|--udp} {-w|--raw} {-x|--unix} --ax25 --ipx --netrom\n"));
 535 +    fprintf(stderr, _("  <Socket>={-t|--tcp} {-u|--udp} {-S|--sctp} {-w|--raw} {-x|--unix} --ax25 --ipx --netrom\n"));
 536      fprintf(stderr, _("  <AF>=Use '-A <af>' or '--<af>'; default: %s\n"), DFLT_AF);
 537      fprintf(stderr, _("  List of possible address families (which support routing):\n"));
 538      print_aflist(1); /* 1 = routeable */
 539 @@ -1769,6 +2153,7 @@
 540         {"protocol", 1, 0, 'A'},
 541         {"tcp", 0, 0, 't'},
 542         {"udp", 0, 0, 'u'},
 543 +       {"sctp", 0, 0, 'S' },
 544         {"raw", 0, 0, 'w'},
 545         {"unix", 0, 0, 'x'},
 546         {"listening", 0, 0, 'l'},
 547 @@ -1801,7 +2186,7 @@
 548
 549      afname[0] = '\0';
 550
 551 -    while ((i = getopt_long(argc, argv, "MCFA:acdegphiI::nNorstuVv?wxlZT", longopts, &lop)) != EOF)
 552 +    while ((i = getopt_long(argc, argv, "MCFA:acdegphiI::nNorstuSVv?wxlZT", longopts, &lop)) != EOF)
 553         switch (i) {
 554         case -1:
 555             break;
 556 @@ -1887,10 +2272,12 @@
 557         case 't':
 558             flag_tcp++;
 559             break;
 560 -
 561         case 'u':
 562             flag_udp++;
 563             break;
 564 +       case 'S':
 565 +           flag_sctp++;
 566 +           break;
 567         case 'w':
 568             flag_raw++;
 569             break;
 570 @@ -1932,13 +2319,13 @@
 571      if (flag_int + flag_rou + flag_mas + flag_sta > 1)
 572         usage();
 573
 574 -    if ((flag_inet || flag_inet6 || flag_sta) && !(flag_tcp || flag_udp || flag_raw))
 575 -       flag_tcp = flag_udp = flag_raw = 1;
 576 +    if ((flag_inet || flag_inet6 || flag_sta) && !(flag_tcp || flag_udp || flag_sctp || flag_raw))
 577 +       flag_tcp = flag_udp = flag_sctp = flag_raw = 1;
 578
 579 -    if ((flag_tcp || flag_udp || flag_raw || flag_igmp) && !(flag_inet || flag_inet6))
 580 +    if ((flag_tcp || flag_udp || flag_sctp || flag_raw || flag_igmp) && !(flag_inet || flag_inet6))
 581          flag_inet = flag_inet6 = 1;
 582
 583 -    flag_arg = flag_tcp + flag_udp + flag_raw + flag_unx + flag_ipx
 584 +    flag_arg = flag_tcp + flag_udp + flag_sctp + flag_raw + flag_unx + flag_ipx
 585         + flag_ax25 + flag_netrom + flag_igmp + flag_x25;
 586
 587      if (flag_mas) {
 588 @@ -1964,7 +2351,7 @@
 589      if (flag_sta) {
 590        for(;;) {
 591          inittab();
 592 -       i = parsesnmp(flag_raw, flag_tcp, flag_udp);
 593 +       i = parsesnmp(flag_raw, flag_tcp, flag_udp, flag_sctp);
 594
 595         if(i || !flag_cnt)
 596           break;
 597 @@ -2006,7 +2393,7 @@
 598         return (i);
 599      }
 600      for (;;) {
 601 -       if (!flag_arg || flag_tcp || flag_udp || flag_raw) {
 602 +       if (!flag_arg || flag_tcp || flag_udp || flag_sctp || flag_raw) {
 603  #if HAVE_AFINET
 604             prg_cache_load();
 605             printf(_("Active Internet connections "));  /* xxx */
 606 @@ -2044,6 +2431,11 @@
 607             if (i)
 608                 return (i);
 609         }
 610 +       if (!flag_arg || flag_sctp) {
 611 +           i = sctp_info();
 612 +           if (i)
 613 +               return (i);
 614 +       }
 615         if (!flag_arg || flag_raw) {
 616             i = raw_info();
 617             if (i)