lib/libhttp
1
0
Fork 0
mirror of https://github.com/lammertb/libhttp.git synced 2025-07-29 21:01:13 +03:00
Code Activity

Documentation: IPv6 ports will listen for both, IPv4 and IPv6

Browse Source 
- Add this to the user documentation
- Make it more clear in the interface documentation
- Change the embedding_c example accordingly (and auto-format the code)
This commit is contained in:
bel2125
2015-09-29 20:43:16 +02:00
parent 28d215e211
commit 73155eea3e
4 changed files with 255 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
docs/UserManual.md
View File

@ -278,6 +278,11 @@ an IP address and a colon must be pre-pended to the port number.
For example, to bind to a loopback interface on port 80 and to For example, to bind to a loopback interface on port 80 and to
all interfaces on HTTPS port 443, use `127.0.0.1:80,443s`. all interfaces on HTTPS port 443, use `127.0.0.1:80,443s`.
If the server is built with IPv6 support, `[::]:8080` can be used to
listen to connections to port 8080 from both, IPv4 and IPv6.
IPv6 addresses of network interfaces can be specified as well,
e.g. `[::1]:8080` for the IPv6 loopback interface.
### document\_root `.` ### document\_root `.`
A directory to serve. By default, the current working directory is served. A directory to serve. By default, the current working directory is served.
The current directory is commonly referenced as dot (`.`). The current directory is commonly referenced as dot (`.`).

429
examples/embedded_c/embedded_c.c
View File

@ -17,7 +17,7 @@
#define DOCUMENT_ROOT "." #define DOCUMENT_ROOT "."
#ifdef USE_IPV6 #ifdef USE_IPV6
#define PORT "8888,[::]:8886" #define PORT "[::]:8888"
#else #else
#define PORT "8888" #define PORT "8888"
#endif #endif
@ -28,284 +28,351 @@ int exitNow = 0;
int ExampleHandler(struct mg_connection *conn, void *cbdata) int ExampleHandler(struct mg_connection *conn, void *cbdata)
{ {
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
mg_printf(conn, "<html><body>"); mg_printf(conn, "<html><body>");
mg_printf(conn, "<h2>This is an example text from a C handler</h2>"); mg_printf(conn, "<h2>This is an example text from a C handler</h2>");
mg_printf(conn, "<p>To see a page from the A handler <a href=\"A\">click A</a></p>"); mg_printf(
mg_printf(conn, "<p>To see a page from the A handler <a href=\"A/A\">click A/A</a></p>"); conn,
mg_printf(conn, "<p>To see a page from the A/B handler <a href=\"A/B\">click A/B</a></p>"); "<p>To see a page from the A handler <a href=\"A\">click A</a></p>");
mg_printf(conn, "<p>To see a page from the B handler (0) <a href=\"B\">click B</a></p>"); mg_printf(conn, "<p>To see a page from the A handler <a href=\"A/A\">click "
mg_printf(conn, "<p>To see a page from the B handler (1) <a href=\"B/A\">click B/A</a></p>"); "A/A</a></p>");
mg_printf(conn, "<p>To see a page from the B handler (2) <a href=\"B/B\">click B/B</a></p>"); mg_printf(conn, "<p>To see a page from the A/B handler <a "
mg_printf(conn, "<p>To see a page from the *.foo handler <a href=\"xy.foo\">click xy.foo</a></p>"); "href=\"A/B\">click A/B</a></p>");
mg_printf(conn, "<p>To see a page from the B handler (0) <a "
"href=\"B\">click B</a></p>");
mg_printf(conn, "<p>To see a page from the B handler (1) <a "
"href=\"B/A\">click B/A</a></p>");
mg_printf(conn, "<p>To see a page from the B handler (2) <a "
"href=\"B/B\">click B/B</a></p>");
mg_printf(conn, "<p>To see a page from the *.foo handler <a "
"href=\"xy.foo\">click xy.foo</a></p>");
#ifdef USE_WEBSOCKET #ifdef USE_WEBSOCKET
mg_printf(conn, "<p>To test websocket handler <a href=\"/websocket\">click websocket</a></p>"); mg_printf(conn, "<p>To test websocket handler <a href=\"/websocket\">click "
"websocket</a></p>");
#endif #endif
mg_printf(conn, "<p>To exit <a href=\"%s\">click exit</a></p>", EXIT_URI); mg_printf(conn, "<p>To exit <a href=\"%s\">click exit</a></p>", EXIT_URI);
mg_printf(conn, "</body></html>\n"); mg_printf(conn, "</body></html>\n");
return 1; return 1;
} }
int ExitHandler(struct mg_connection *conn, void *cbdata) int ExitHandler(struct mg_connection *conn, void *cbdata)
{ {
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\n");
mg_printf(conn, "Bye!\n"); mg_printf(conn, "Bye!\n");
exitNow = 1; exitNow = 1;
return 1; return 1;
} }
int AHandler(struct mg_connection *conn, void *cbdata) int AHandler(struct mg_connection *conn, void *cbdata)
{ {
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
mg_printf(conn, "<html><body>"); mg_printf(conn, "<html><body>");
mg_printf(conn, "<h2>This is the A handler!!!</h2>"); mg_printf(conn, "<h2>This is the A handler!!!</h2>");
mg_printf(conn, "</body></html>\n"); mg_printf(conn, "</body></html>\n");
return 1; return 1;
} }
int ABHandler(struct mg_connection *conn, void *cbdata) int ABHandler(struct mg_connection *conn, void *cbdata)
{ {
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
mg_printf(conn, "<html><body>"); mg_printf(conn, "<html><body>");
mg_printf(conn, "<h2>This is the AB handler!!!</h2>"); mg_printf(conn, "<h2>This is the AB handler!!!</h2>");
mg_printf(conn, "</body></html>\n"); mg_printf(conn, "</body></html>\n");
return 1; return 1;
} }
int BXHandler(struct mg_connection *conn, void *cbdata) int BXHandler(struct mg_connection *conn, void *cbdata)
{ {
/* Handler may access the request info using mg_get_request_info */ /* Handler may access the request info using mg_get_request_info */
const struct mg_request_info * req_info = mg_get_request_info(conn); const struct mg_request_info *req_info = mg_get_request_info(conn);
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
mg_printf(conn, "<html><body>"); mg_printf(conn, "<html><body>");
mg_printf(conn, "<h2>This is the BX handler %p!!!</h2>", cbdata); mg_printf(conn, "<h2>This is the BX handler %p!!!</h2>", cbdata);
mg_printf(conn, "<p>The actual uri is %s</p>", req_info->uri); mg_printf(conn, "<p>The actual uri is %s</p>", req_info->uri);
mg_printf(conn, "</body></html>\n"); mg_printf(conn, "</body></html>\n");
return 1; return 1;
} }
int FooHandler(struct mg_connection *conn, void *cbdata) int FooHandler(struct mg_connection *conn, void *cbdata)
{ {
/* Handler may access the request info using mg_get_request_info */ /* Handler may access the request info using mg_get_request_info */
const struct mg_request_info * req_info = mg_get_request_info(conn); const struct mg_request_info *req_info = mg_get_request_info(conn);
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
mg_printf(conn, "<html><body>"); mg_printf(conn, "<html><body>");
mg_printf(conn, "<h2>This is the Foo handler!!!</h2>"); mg_printf(conn, "<h2>This is the Foo handler!!!</h2>");
mg_printf(conn, "<p>The request was:<br><pre>%s %s HTTP/%s</pre></p>", mg_printf(conn,
req_info->request_method, req_info->uri, req_info->http_version); "<p>The request was:<br><pre>%s %s HTTP/%s</pre></p>",
mg_printf(conn, "</body></html>\n"); req_info->request_method,
return 1; req_info->uri,
req_info->http_version);
mg_printf(conn, "</body></html>\n");
return 1;
} }
int WebSocketStartHandler(struct mg_connection *conn, void *cbdata) int WebSocketStartHandler(struct mg_connection *conn, void *cbdata)
{ {
mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"); mg_printf(conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n");
mg_printf(conn, "<!DOCTYPE html>\n"); mg_printf(conn, "<!DOCTYPE html>\n");
mg_printf(conn, "<html>\n<head>\n"); mg_printf(conn, "<html>\n<head>\n");
mg_printf(conn, "<meta charset=\"UTF-8\">\n"); mg_printf(conn, "<meta charset=\"UTF-8\">\n");
mg_printf(conn, "<title>Embedded websocket example</title>\n"); mg_printf(conn, "<title>Embedded websocket example</title>\n");
#ifdef USE_WEBSOCKET #ifdef USE_WEBSOCKET
/* mg_printf(conn, "<script type=\"text/javascript\"><![CDATA[\n"); ... xhtml style */ /* mg_printf(conn, "<script type=\"text/javascript\"><![CDATA[\n"); ...
mg_printf(conn, "<script>\n"); * xhtml style */
mg_printf(conn, mg_printf(conn, "<script>\n");
"function load() {\n" mg_printf(
" var wsproto = (location.protocol === 'https:') ? 'wss:' : 'ws:';\n" conn,
" connection = new WebSocket(wsproto + '//' + window.location.host + '/websocket');\n" "function load() {\n"
" websock_text_field = document.getElementById('websock_text_field');\n" " var wsproto = (location.protocol === 'https:') ? 'wss:' : 'ws:';\n"
" connection.onmessage = function (e) {\n" " connection = new WebSocket(wsproto + '//' + window.location.host + "
" websock_text_field.innerHTML=e.data;\n" "'/websocket');\n"
" }\n" " websock_text_field = "
" connection.onerror = function (error) {\n" "document.getElementById('websock_text_field');\n"
" alert('WebSocket error');\n" " connection.onmessage = function (e) {\n"
" connection.close();\n" " websock_text_field.innerHTML=e.data;\n"
" }\n" " }\n"
"}\n" " connection.onerror = function (error) {\n"
); " alert('WebSocket error');\n"
/* mg_printf(conn, "]]></script>\n"); ... xhtml style */ " connection.close();\n"
mg_printf(conn, "</script>\n"); " }\n"
mg_printf(conn, "</head>\n<body onload=\"load()\">\n"); "}\n");
mg_printf(conn, "<div id='websock_text_field'>No websocket connection yet</div>\n"); /* mg_printf(conn, "]]></script>\n"); ... xhtml style */
mg_printf(conn, "</script>\n");
mg_printf(conn, "</head>\n<body onload=\"load()\">\n");
mg_printf(
conn,
"<div id='websock_text_field'>No websocket connection yet</div>\n");
#else #else
mg_printf(conn, "</head>\n<body>\n"); mg_printf(conn, "</head>\n<body>\n");
mg_printf(conn, "Example not compiled with USE_WEBSOCKET\n"); mg_printf(conn, "Example not compiled with USE_WEBSOCKET\n");
#endif #endif
mg_printf(conn, "</body>\n</html>\n"); mg_printf(conn, "</body>\n</html>\n");
return 1; return 1;
} }
#ifdef USE_WEBSOCKET #ifdef USE_WEBSOCKET
#define MAX_WS_CLIENTS 5 /* just for the test: a small number that can be reached */ #define MAX_WS_CLIENTS \
/* a real server should use a much higher number here */ 5 /* just for the test: a small number that can be reached */
/* a real server should use a much higher number here */
struct t_ws_client { struct t_ws_client {
struct mg_connection * conn; struct mg_connection *conn;
int state; int state;
} static ws_clients[MAX_WS_CLIENTS]; } static ws_clients[MAX_WS_CLIENTS];
#define ASSERT(x) {if (!(x)) {fprintf(stderr, "Assertion failed in line %u\n", (unsigned)__LINE__);}} #define ASSERT(x) \
{ \
if (!(x)) { \
fprintf( \
stderr, "Assertion failed in line %u\n", (unsigned)__LINE__); \
} \
}
static unsigned long cnt; static unsigned long cnt;
int WebSocketConnectHandler(const struct mg_connection * conn, void *cbdata) int WebSocketConnectHandler(const struct mg_connection *conn, void *cbdata)
{ {
struct mg_context *ctx = mg_get_context(conn); struct mg_context *ctx = mg_get_context(conn);
int reject = 1; int reject = 1;
int i; int i;
mg_lock_context(ctx); mg_lock_context(ctx);
for (i=0; i<MAX_WS_CLIENTS; i++) { for (i = 0; i < MAX_WS_CLIENTS; i++) {
if (ws_clients[i].conn == NULL) { if (ws_clients[i].conn == NULL) {
ws_clients[i].conn = (struct mg_connection *) conn; ws_clients[i].conn = (struct mg_connection *)conn;
ws_clients[i].state = 1; ws_clients[i].state = 1;
mg_set_user_connection_data(conn, (void*) (ws_clients+i)); mg_set_user_connection_data(conn, (void *)(ws_clients + i));
reject = 0; reject = 0;
break; break;
} }
} }
mg_unlock_context(ctx); mg_unlock_context(ctx);
fprintf(stdout, "Websocket client %s\r\n\r\n", (reject ? "rejected" : "accepted")); fprintf(stdout,
return reject; "Websocket client %s\r\n\r\n",
(reject ? "rejected" : "accepted"));
return reject;
} }
void WebSocketReadyHandler(struct mg_connection * conn, void *cbdata) void WebSocketReadyHandler(struct mg_connection *conn, void *cbdata)
{ {
const char * text = "Hello from the websocket ready handler"; const char *text = "Hello from the websocket ready handler";
struct t_ws_client * client = mg_get_user_connection_data(conn); struct t_ws_client *client = mg_get_user_connection_data(conn);
mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, text, strlen(text)); mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, text, strlen(text));
fprintf(stdout, "Greeting message sent to websocket client\r\n\r\n"); fprintf(stdout, "Greeting message sent to websocket client\r\n\r\n");
ASSERT(client->conn == conn); ASSERT(client->conn == conn);
ASSERT(client->state == 1); ASSERT(client->state == 1);
client->state = 2; client->state = 2;
} }
int WebsocketDataHandler(struct mg_connection * conn, int bits, char * data, size_t len, void *cbdata) int WebsocketDataHandler(struct mg_connection *conn,
int bits,
char *data,
size_t len,
void *cbdata)
{ {
struct t_ws_client * client = mg_get_user_connection_data(conn); struct t_ws_client *client = mg_get_user_connection_data(conn);
ASSERT(client->conn == conn); ASSERT(client->conn == conn);
ASSERT(client->state >= 1); ASSERT(client->state >= 1);
fprintf(stdout, "Websocket got data:\r\n"); fprintf(stdout, "Websocket got data:\r\n");
fwrite(data, len, 1, stdout); fwrite(data, len, 1, stdout);
fprintf(stdout, "\r\n\r\n"); fprintf(stdout, "\r\n\r\n");
return 1; return 1;
} }
void WebSocketCloseHandler(const struct mg_connection * conn, void *cbdata) void WebSocketCloseHandler(const struct mg_connection *conn, void *cbdata)
{ {
struct mg_context *ctx = mg_get_context(conn); struct mg_context *ctx = mg_get_context(conn);
struct t_ws_client * client = mg_get_user_connection_data(conn); struct t_ws_client *client = mg_get_user_connection_data(conn);
ASSERT(client->conn == conn); ASSERT(client->conn == conn);
ASSERT(client->state >= 1); ASSERT(client->state >= 1);
mg_lock_context(ctx); mg_lock_context(ctx);
client->state = 0; client->state = 0;
client->conn = NULL; client->conn = NULL;
mg_unlock_context(ctx); mg_unlock_context(ctx);
fprintf(stdout, "Client droped from the set of webserver connections\r\n\r\n"); fprintf(stdout,
"Client droped from the set of webserver connections\r\n\r\n");
} }
void InformWebsockets(struct mg_context *ctx) void InformWebsockets(struct mg_context *ctx)
{ {
char text[32]; char text[32];
int i; int i;
sprintf(text, "%lu", ++cnt); sprintf(text, "%lu", ++cnt);
mg_lock_context(ctx); mg_lock_context(ctx);
for (i=0; i<MAX_WS_CLIENTS; i++) { for (i = 0; i < MAX_WS_CLIENTS; i++) {
if (ws_clients[i].state == 2) { if (ws_clients[i].state == 2) {
mg_websocket_write(ws_clients[i].conn, WEBSOCKET_OPCODE_TEXT, text, strlen(text)); mg_websocket_write(
} ws_clients[i].conn, WEBSOCKET_OPCODE_TEXT, text, strlen(text));
} }
mg_unlock_context(ctx); }
mg_unlock_context(ctx);
} }
#endif #endif
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
const char * options[] = { "document_root", DOCUMENT_ROOT, const char *options[] = {"document_root",
"listening_ports", PORT, DOCUMENT_ROOT,
"request_timeout_ms", "10000", "listening_ports",
PORT,
"request_timeout_ms",
"10000",
"error_log_file",
"error.log",
#ifdef USE_WEBSOCKET #ifdef USE_WEBSOCKET
"websocket_timeout_ms", "3600000", "websocket_timeout_ms",
"3600000",
#endif #endif
0 0};
}; struct mg_callbacks callbacks;
struct mg_callbacks callbacks; struct mg_context *ctx;
struct mg_context *ctx; struct mg_server_ports ports[32];
struct mg_server_ports ports[32]; int port_cnt, n;
int port_cnt, n;
memset(&callbacks, 0, sizeof(callbacks)); memset(&callbacks, 0, sizeof(callbacks));
ctx = mg_start(&callbacks, 0, options); ctx = mg_start(&callbacks, 0, options);
/* Handler EXAMPLE_URI to explain the example */ /* Handler EXAMPLE_URI to explain the example */
mg_set_request_handler(ctx, EXAMPLE_URI, ExampleHandler, 0); mg_set_request_handler(ctx, EXAMPLE_URI, ExampleHandler, 0);
mg_set_request_handler(ctx, EXIT_URI, ExitHandler, 0); mg_set_request_handler(ctx, EXIT_URI, ExitHandler, 0);
/* Handler for /A* and special handler for /A/B */ /* Handler for /A* and special handler for /A/B */
mg_set_request_handler(ctx, "/A", AHandler, 0); mg_set_request_handler(ctx, "/A", AHandler, 0);
mg_set_request_handler(ctx, "/A/B", ABHandler, 0); mg_set_request_handler(ctx, "/A/B", ABHandler, 0);
/* Handler for /B, /B/A, /B/B but not for /B* */ /* Handler for /B, /B/A, /B/B but not for /B* */
mg_set_request_handler(ctx, "/B$", BXHandler, (void*)0); mg_set_request_handler(ctx, "/B$", BXHandler, (void *)0);
mg_set_request_handler(ctx, "/B/A$", BXHandler, (void*)1); mg_set_request_handler(ctx, "/B/A$", BXHandler, (void *)1);
mg_set_request_handler(ctx, "/B/B$", BXHandler, (void*)2); mg_set_request_handler(ctx, "/B/B$", BXHandler, (void *)2);
/* Handler for all files with .foo extention */ /* Handler for all files with .foo extention */
mg_set_request_handler(ctx, "**.foo$", FooHandler, 0); mg_set_request_handler(ctx, "**.foo$", FooHandler, 0);
/* HTTP site to open a websocket connection */ /* HTTP site to open a websocket connection */
mg_set_request_handler(ctx, "/websocket", WebSocketStartHandler, 0); mg_set_request_handler(ctx, "/websocket", WebSocketStartHandler, 0);
#ifdef USE_WEBSOCKET #ifdef USE_WEBSOCKET
/* WS site for the websocket connection */ /* WS site for the websocket connection */
mg_set_websocket_handler(ctx, "/websocket", WebSocketConnectHandler, WebSocketReadyHandler, WebsocketDataHandler, WebSocketCloseHandler, 0); mg_set_websocket_handler(ctx,
"/websocket",
WebSocketConnectHandler,
WebSocketReadyHandler,
WebsocketDataHandler,
WebSocketCloseHandler,
0);
#endif #endif
memset(ports, 0, sizeof(ports));
port_cnt = mg_get_server_ports(ctx, 32, ports);
printf("\n%i listening ports:\n\n", port_cnt);
for (n=0; n<port_cnt && n<32; n++) { memset(ports, 0, sizeof(ports));
const char *proto = ports[n].is_ssl ? "https" : "http"; port_cnt = mg_get_server_ports(ctx, 32, ports);
const char *host = ports[n].protocol==2 ? "[::1]" : "127.0.0.1"; printf("\n%i listening ports:\n\n", port_cnt);
printf("Browse files at %s://%s:%i/\n", proto, host, ports[n].port);
printf("Run example at %s://%s:%i%s\n", proto, host, ports[n].port, EXAMPLE_URI);
printf("Exit at %s://%s:%i%s\n", proto, host, ports[n].port, EXIT_URI);
printf("\n");
}
while (!exitNow) { for (n = 0; n < port_cnt && n < 32; n++) {
const char *proto = ports[n].is_ssl ? "https" : "http";
const char *host;
if ((ports[n].protocol & 1) == 1) {
/* IPv4 */
host = "127.0.0.1";
printf("Browse files at %s://%s:%i/\n", proto, host, ports[n].port);
printf("Run example at %s://%s:%i%s\n",
proto,
host,
ports[n].port,
EXAMPLE_URI);
printf(
"Exit at %s://%s:%i%s\n", proto, host, ports[n].port, EXIT_URI);
printf("\n");
}
if ((ports[n].protocol & 2) == 2) {
/* IPv6 */
host = "[::1]";
printf("Browse files at %s://%s:%i/\n", proto, host, ports[n].port);
printf("Run example at %s://%s:%i%s\n",
proto,
host,
ports[n].port,
EXAMPLE_URI);
printf(
"Exit at %s://%s:%i%s\n", proto, host, ports[n].port, EXIT_URI);
printf("\n");
}
}
while (!exitNow) {
#ifdef _WIN32 #ifdef _WIN32
Sleep(1000); Sleep(1000);
#else #else
sleep(1); sleep(1);
#endif #endif
#ifdef USE_WEBSOCKET #ifdef USE_WEBSOCKET
InformWebsockets(ctx); InformWebsockets(ctx);
#endif #endif
} }
mg_stop(ctx); mg_stop(ctx);
printf("Bye!\n"); printf("Bye!\n");
return 0; return 0;
} }

2
include/civetweb.h
View File

@ -388,7 +388,7 @@ CIVETWEB_API const struct mg_option *mg_get_valid_options(void);
struct mg_server_ports { struct mg_server_ports {
int protocol; /* 1 = IPv4, 2 = IPv6 */ int protocol; /* 1 = IPv4, 2 = IPv6, 3 = both */
int port; /* port number */ int port; /* port number */
int is_ssl; /* https port: 0 = no, 1 = yes */ int is_ssl; /* https port: 0 = no, 1 = yes */
int is_redirect; /* redirect all requests: 0 = no, 1 = yes */ int is_redirect; /* redirect all requests: 0 = no, 1 = yes */

2
src/civetweb.c
View File

@ -1607,7 +1607,7 @@ int mg_get_server_ports(const struct mg_context *ctx,
cnt++; cnt++;
} else if (ctx->listening_sockets[i].lsa.sa.sa_family == AF_INET6) { } else if (ctx->listening_sockets[i].lsa.sa.sa_family == AF_INET6) {
/* IPv6 */ /* IPv6 */
ports[cnt].protocol = 2; ports[cnt].protocol = 3;
cnt++; cnt++;
} }
} }