]>
Commit | Line | Data |
---|---|---|
236898d6 MT |
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) |