Mercurial > ecos
annotate packages/net/athttpd/current/src/socket.c @ 2255:3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
Modified slightly the source of cyg_httpd_write and cyg_httpd_writev
to make the code more consistent as to when assertions are thrown.
| author | jlarmour |
|---|---|
| date | Thu, 20 Jul 2006 18:55:04 +0000 |
| parents | 0830ae6acddc |
| children | b5670f3c40f2 |
| rev | line source |
|---|---|
| 2250 | 1 /* ================================================================= |
| 2 * | |
| 3 * socket.c | |
| 4 * | |
| 5 * Opens socket and starts the daemon. | |
| 6 * | |
| 7 * ================================================================= | |
| 8 * ####ECOSGPLCOPYRIGHTBEGIN#### | |
| 9 * ------------------------------------------- | |
| 10 * This file is part of eCos, the Embedded Configurable Operating | |
| 11 * System. | |
| 12 * Copyright (C) 2005 eCosCentric Ltd. | |
| 13 * | |
| 14 * eCos is free software; you can redistribute it and/or modify it | |
| 15 * under the terms of the GNU General Public License as published by | |
| 16 * the Free Software Foundation; either version 2 or (at your option) | |
| 17 * any later version. | |
| 18 * | |
| 19 * eCos is distributed in the hope that it will be useful, but | |
| 20 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 22 * General Public License for more details. | |
| 23 * | |
| 24 * You should have received a copy of the GNU General Public License | |
| 25 * along with eCos; if not, write to the Free Software Foundation, | |
| 26 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. | |
| 27 * | |
| 28 * As a special exception, if other files instantiate templates or | |
| 29 * use macros or inline functions from this file, or you compile this | |
| 30 * file and link it with other works to produce a work based on this | |
| 31 * file, this file does not by itself cause the resulting work to be | |
| 32 * covered by the GNU General Public License. However the source code | |
| 33 * for this file must still be made available in accordance with | |
| 34 * section (3) of the GNU General Public License. | |
| 35 * | |
| 36 * This exception does not invalidate any other reasons why a work | |
| 37 * based on this file might be covered by the GNU General Public | |
| 38 * License. | |
| 39 * | |
| 40 * ------------------------------------------- | |
| 41 * ####ECOSGPLCOPYRIGHTEND#### | |
| 42 * ================================================================= | |
| 43 * #####DESCRIPTIONBEGIN#### | |
| 44 * | |
| 45 * Author(s): Anthony Tonizzo (atonizzo@gmail.com) | |
| 46 * Contributors: | |
| 47 * Date: 2006-06-12 | |
| 48 * Purpose: | |
| 49 * Description: | |
| 50 * | |
| 51 * ####DESCRIPTIONEND#### | |
| 52 * | |
| 53 * ================================================================= | |
| 54 */ | |
| 55 #include <pkgconf/hal.h> | |
| 56 #include <pkgconf/kernel.h> | |
| 57 #include <cyg/kernel/kapi.h> // Kernel API. | |
| 58 #include <cyg/kernel/ktypes.h> // base kernel types. | |
| 59 #include <cyg/infra/diag.h> // For diagnostic printing. | |
| 60 #include <network.h> | |
| 61 #include <sys/uio.h> | |
| 62 #include <fcntl.h> | |
| 63 #include <stdio.h> // sprintf(). | |
| 64 #include <time.h> // sprintf(). | |
| 65 | |
| 66 #include <cyg/athttpd/http.h> | |
| 67 #include <cyg/athttpd/socket.h> | |
| 68 #include <cyg/athttpd/cgi.h> | |
| 69 | |
| 70 #define MAX(X, Y) ((X) > (Y) ? (X) : (Y)) | |
| 71 #define CYG_HTTPD_DAEMON_STACK_SIZE (CYGNUM_HAL_STACK_SIZE_MINIMUM + \ | |
| 72 CYGNUM_NET_ATHTTPD_THREADOPT_STACKSIZE) | |
| 73 static cyg_int32 cyg_httpd_initialized = 0; | |
| 74 cyg_thread cyg_httpd_thread_object; | |
| 75 cyg_handle_t cyg_httpd_thread_handle; | |
| 76 cyg_uint8 cyg_httpd_thread_stack[CYG_HTTPD_DAEMON_STACK_SIZE] | |
| 77 __attribute__((__aligned__ (16))); | |
| 78 CYG_HTTPD_STATE httpstate; | |
| 79 | |
| 80 __inline__ ssize_t | |
|
2255
3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
jlarmour
parents:
2250
diff
changeset
|
81 cyg_httpd_write(char* buf, int buf_len) |
| 2250 | 82 { |
| 83 // We are not going to write anything in case | |
| 84 ssize_t sent = send(httpstate.sockets[httpstate.client_index].descriptor, | |
| 85 buf, | |
|
2255
3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
jlarmour
parents:
2250
diff
changeset
|
86 buf_len, |
| 2250 | 87 0); |
|
2255
3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
jlarmour
parents:
2250
diff
changeset
|
88 CYG_ASSERT(sent == buf_len, "send() did not send out all bytes"); |
| 2250 | 89 return sent; |
| 90 } | |
| 91 | |
| 92 __inline__ ssize_t | |
|
2255
3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
jlarmour
parents:
2250
diff
changeset
|
93 cyg_httpd_writev(cyg_iovec *iovec_bufs, int count) |
| 2250 | 94 { |
|
2255
3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
jlarmour
parents:
2250
diff
changeset
|
95 int i; |
|
3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
jlarmour
parents:
2250
diff
changeset
|
96 ssize_t sent = writev(httpstate.sockets[httpstate.client_index].descriptor, |
|
3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
jlarmour
parents:
2250
diff
changeset
|
97 iovec_bufs, |
|
3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
jlarmour
parents:
2250
diff
changeset
|
98 count); |
|
3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
jlarmour
parents:
2250
diff
changeset
|
99 ssize_t buf_len = 0; |
|
3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
jlarmour
parents:
2250
diff
changeset
|
100 for (i = 0; i < count; i++) |
|
3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
jlarmour
parents:
2250
diff
changeset
|
101 buf_len += iovec_bufs[i].iov_len; |
|
3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
jlarmour
parents:
2250
diff
changeset
|
102 CYG_ASSERT(sent == buf_len, "writev() did not send out all bytes"); |
|
3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
jlarmour
parents:
2250
diff
changeset
|
103 return sent; |
| 2250 | 104 } |
| 105 | |
| 106 // The need for chunked transfers arises from the fact that with dinamic | |
| 107 // pages it is not always possible to know the packet size upfront, and thus | |
| 108 // it is not possible to fill the Content-Length: field in the header. | |
| 109 // Today's web browser apparently do not even use 'Content-Length:' because | |
| 110 // many sites that generate dinamic frames send a header with a length of 0. | |
| 111 // Even though this system works (the browsers probably reads everything that | |
| 112 // comes in before the socket is closed and then figure it out) the HTTP | |
| 113 // standard _mandates_ the Content-Length: with a correct valie, and whenever | |
| 114 // that is not possible, chunked transfers must be used. | |
| 115 // This function also handles the case of a chunked frame. | |
| 116 // | |
| 117 // A chunked transer takes the form of: | |
| 118 // ----------------------------------------------------------------------------- | |
| 119 // cyg_httpd_start_chunked("html"); | |
| 120 // sprintf(phttpstate->payload, ...); | |
| 121 // cyg_httpd_write_chunked(phttpstate->payload, | |
| 122 // strlen(phttpstate->payload)); | |
| 123 // ... | |
| 124 // cyg_httpd_end_chunked(); | |
| 125 // ----------------------------------------------------------------------------- | |
| 126 ssize_t | |
| 127 cyg_httpd_start_chunked(char *extension) | |
| 128 { | |
| 129 httpstate.status_code = CYG_HTTPD_STATUS_OK; | |
| 130 httpstate.mode |= CYG_HTTPD_MODE_TRANSFER_CHUNKED; | |
| 131 | |
| 132 // I am not really sure that this is necessary, but even if it isn't, the | |
| 133 // added overhead is not such a big deal. In simple terms, I am not sure | |
| 134 // how much I can rely the client to understand that the frame has ended | |
| 135 // with the last 5 bytes sent out. In an ideal world, the data '0\r\n\r\n' | |
| 136 // should be enough, but several posting I read seem to imply otherwise, | |
| 137 // at least with early generation browsers that supported the | |
| 138 // "Transfer-Encoding: chunked" mechanism. Things might be getting better | |
| 139 // now but I snooped some sites that use the chunked stuff and all of them | |
| 140 // with no exception issue a "Connection: close" on chunked frames even | |
| 141 // if there is nothing in the HTTP 1.1 spec that requires it. | |
| 142 httpstate.mode |= CYG_HTTPD_MODE_CLOSE_CONN; | |
| 143 | |
| 144 // We do not cache the CGI script. In case they are used to display | |
| 145 // dynamic data we want them to be executed any every time they are | |
| 146 // requested. | |
| 147 httpstate.last_modified = -1; | |
| 148 httpstate.mime_type = cyg_httpd_find_mime_string(extension); | |
| 149 cyg_int32 header_length = cyg_httpd_format_header(); | |
|
2255
3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
jlarmour
parents:
2250
diff
changeset
|
150 return cyg_httpd_write(httpstate.outbuffer, header_length); |
| 2250 | 151 } |
| 152 | |
| 153 ssize_t | |
| 154 cyg_httpd_write_chunked(char* buf, int len) | |
| 155 { | |
| 156 char leader[16], trailer[] = {'\r', '\n'}; | |
| 157 | |
| 158 cyg_iovec iovec_bufs[] = { {leader, 0}, {buf, 0}, {trailer, 2} }; | |
| 159 sprintf(leader, "%x\r\n", len); | |
| 160 iovec_bufs[0].iov_len = strlen(leader); | |
| 161 iovec_bufs[1].iov_len = len; | |
| 162 iovec_bufs[2].iov_len = 2; | |
| 163 if (httpstate.mode & CYG_HTTPD_SEND_HEADER_ONLY) | |
| 164 return (iovec_bufs[0].iov_len + iovec_bufs[1].iov_len + | |
| 165 iovec_bufs[2].iov_len); | |
|
2255
3327c37c28d1
* src/socket.c: Corrected a typo that generated an assertion.
jlarmour
parents:
2250
diff
changeset
|
166 return cyg_httpd_writev(iovec_bufs, 3); |
| 2250 | 167 } |
| 168 | |
| 169 void | |
| 170 cyg_httpd_end_chunked(void) | |
| 171 { | |
| 172 if (httpstate.mode & CYG_HTTPD_SEND_HEADER_ONLY) | |
| 173 return; | |
| 174 strcpy(httpstate.outbuffer, "0\r\n\r\n"); | |
| 175 cyg_httpd_write(httpstate.outbuffer, 5); | |
| 176 httpstate.mode &= ~CYG_HTTPD_MODE_TRANSFER_CHUNKED; | |
| 177 } | |
| 178 | |
| 179 // This function builds and send out a standard header. It is likely going to | |
| 180 // be used by a c language callback function, and thus followed by one or | |
| 181 // more calls to cyg_httpd_write(). Unlike cyg_httpd_start_chunked(), this | |
| 182 // call requires prior knowledge of the final size of the frame, and the user | |
| 183 // is expected to make sure that the total number of bytes (octets) sent out | |
| 184 // via 'cyg_httpd_write()' matches the number passed in the len parameter. | |
| 185 // Its use it thus more limited, and the more flexible chunked frames should | |
| 186 // be used whenever possible. | |
| 187 void | |
| 188 cyg_httpd_create_std_header(char *extension, int len) | |
| 189 { | |
| 190 httpstate.status_code = CYG_HTTPD_STATUS_OK; | |
| 191 httpstate.mode = 0; | |
| 192 | |
| 193 // We do not want to send out a "Last-Modified:" field for c language | |
| 194 // callbacks. | |
| 195 httpstate.last_modified = -1; | |
| 196 httpstate.mime_type = cyg_httpd_find_mime_string(extension); | |
| 197 httpstate.payload_len = len; | |
| 198 cyg_int32 header_length = cyg_httpd_format_header(); | |
| 199 cyg_httpd_write(httpstate.outbuffer, header_length); | |
| 200 } | |
| 201 | |
| 202 void | |
| 203 cyg_httpd_process_request(cyg_int32 index) | |
| 204 { | |
| 205 int rc = 1; | |
| 206 httpstate.client_index = index; | |
| 207 cyg_int32 descr = httpstate.sockets[index].descriptor; | |
| 208 fd_set rfds_tmp; | |
| 209 FD_ZERO( &rfds_tmp); | |
| 210 FD_SET( descr, &rfds_tmp); | |
| 211 while (FD_ISSET(descr, &rfds_tmp)) | |
| 212 { | |
| 213 cyg_int32 n = recv(descr, httpstate.inbuffer, CYG_HTTPD_MAXINBUFFER, 0); | |
| 214 if (n == 0) | |
| 215 { | |
| 216 // This is the client that has closed its TX socket, possibly as | |
| 217 // a response from a shutdown() initiated by the server. Another | |
| 218 // possibility is that the client was closed altogether, in | |
| 219 // which case EOFs are sent on each open sockets. | |
| 220 #if CYGOPT_NET_ATHTTPD_DEBUG_LEVEL > 0 | |
| 221 printf("EOF received on descriptor: %d. Closing it.\n", descr); | |
| 222 #endif | |
| 223 close(descr); | |
| 224 FD_CLR(descr, &httpstate.rfds); | |
| 225 httpstate.sockets[index].descriptor = 0; | |
| 226 return; | |
| 227 } | |
| 228 | |
| 229 if (n < 0) | |
| 230 { | |
| 231 diag_printf("ERROR reading from socket. read() returned: %d\n", n); | |
| 232 return; | |
| 233 } | |
| 234 httpstate.inbuffer[n] = '\0'; | |
| 235 | |
| 236 // Timestamp the socket. | |
| 237 httpstate.sockets[index].timestamp = time(NULL); | |
| 238 | |
| 239 // This is where it all happens. | |
| 240 cyg_httpd_process_method(); | |
| 241 | |
| 242 if (httpstate.mode & CYG_HTTPD_MODE_CLOSE_CONN) | |
| 243 // There are 2 cases we can be here: | |
| 244 // 1) chunked frames close their connection by default | |
| 245 // 2) The client requested the connection be terminated. | |
| 246 // In any case, we close the TX pipe, and wait for the client to | |
| 247 // send us an EOF on the receive pipe. This is a more graceful way | |
| 248 // to handle the closing of the socket, compared to just calling | |
| 249 // close() without first asking the opinion of the client, and | |
| 250 // running the risk of stray data lingering around. | |
| 251 shutdown(descr, SHUT_WR); | |
| 252 | |
| 253 // Now check if we have pipelined frames. We'll set up a | |
| 254 // select() to see if more data is waiting to be read. Pipeline is | |
| 255 // still not enabled by default in most browsers. | |
| 256 struct timeval tv_tmp = {0, 20000}; | |
| 257 rc = select(descr + 1, &rfds_tmp, NULL, NULL, &tv_tmp); | |
| 258 CYG_ASSERT(rc != -1, "select() return -1"); | |
| 259 if (rc == 0) | |
| 260 return; | |
| 261 } | |
| 262 } | |
| 263 | |
| 264 void | |
| 265 cyg_httpd_handle_new_connection(cyg_int32 listener) | |
| 266 { | |
| 267 cyg_int32 i; | |
| 268 | |
| 269 int fd_client = accept(listener, NULL, NULL); | |
| 270 CYG_ASSERT(listener != -1, "accept() failed"); | |
| 271 if (fd_client == -1) | |
| 272 return; | |
| 273 | |
| 274 #if CYGOPT_NET_ATHTTPD_DEBUG_LEVEL > 0 | |
| 275 printf("Opening descriptor: %d\n", fd_client); | |
| 276 #endif | |
| 277 // Timestamp the socket and process the frame immediately, since the accept | |
| 278 // guarantees the presence of valid data on the newly opened socket. | |
| 279 for (i = 0; i < CYGPKG_NET_MAXSOCKETS; i++) | |
| 280 if (httpstate.sockets[i].descriptor == 0) | |
| 281 { | |
| 282 httpstate.sockets[i].descriptor = fd_client; | |
| 283 httpstate.sockets[i].timestamp = time(NULL); | |
| 284 cyg_httpd_process_request(i); | |
| 285 return; | |
| 286 } | |
| 287 } | |
| 288 | |
| 289 // This is the "garbage collector" (or better, the "garbage disposer") of | |
| 290 // the server. It closes any socket that has been idle for a time period | |
| 291 // of CYG_HTTPD_SELECT_TIMEOUT seconds. | |
| 292 void | |
| 293 cyg_httpd_close_unused_sockets(cyg_int32 listener) | |
| 294 { | |
| 295 cyg_int32 i; | |
| 296 | |
| 297 #if CYGOPT_NET_ATHTTPD_DEBUG_LEVEL > 0 | |
| 298 diag_printf("Garbage collector called\r\n"); | |
| 299 #endif | |
| 300 httpstate.fdmax = listener; | |
| 301 for (i = 0; i < CYGPKG_NET_MAXSOCKETS; i++) | |
| 302 { | |
| 303 if (httpstate.sockets[i].descriptor != 0) | |
| 304 { | |
| 305 if (time(NULL) - httpstate.sockets[i].timestamp > | |
| 306 CYG_HTTPD_SOCKET_IDLE_TIMEOUT) | |
| 307 { | |
| 308 #if CYGOPT_NET_ATHTTPD_DEBUG_LEVEL > 0 | |
| 309 diag_printf("Closing descriptor: %d\n", | |
| 310 httpstate.sockets[i].descriptor); | |
| 311 #endif | |
| 312 shutdown(httpstate.sockets[i].descriptor, SHUT_WR); | |
| 313 } | |
| 314 else | |
| 315 httpstate.fdmax = MAX(httpstate.fdmax, | |
| 316 httpstate.sockets[i].descriptor); | |
| 317 } | |
| 318 } | |
| 319 } | |
| 320 | |
| 321 void | |
| 322 cyg_httpd_daemon(cyg_addrword_t data) | |
| 323 { | |
| 324 cyg_int32 rc; | |
| 325 init_all_network_interfaces(); | |
| 326 | |
| 327 #if CYGOPT_NET_ATHTTPD_DEBUG_LEVEL > 0 | |
| 328 #ifdef CYGHWR_NET_DRIVER_ETH0 | |
| 329 if (eth0_up) | |
| 330 { | |
| 331 struct bootp* bps = ð0_bootp_data; | |
| 332 diag_printf("ETH0 is up. IP address: %s\n", inet_ntoa(bps->bp_yiaddr)); | |
| 333 } | |
| 334 #endif | |
| 335 #endif | |
| 336 | |
| 337 #ifdef CYGOPT_NET_ATHTTPD_USE_CGIBIN_TCL | |
| 338 cyg_httpd_init_tcl_interpreter(); | |
| 339 #endif | |
| 340 | |
| 341 cyg_httpd_initialize(); | |
| 342 | |
| 343 // Get the network going. This is benign if the application has | |
| 344 // already done this. | |
| 345 cyg_int32 listener = socket(AF_INET, SOCK_STREAM, 0); | |
| 346 CYG_ASSERT(listener > 0, "Socket create failed"); | |
| 347 if (listener < 0) | |
| 348 return; | |
| 349 | |
| 350 cyg_int32 yes = 1; | |
| 351 rc = setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)); | |
| 352 if (rc == -1) | |
| 353 return; | |
| 354 | |
| 355 memset(&(httpstate.server_conn), 0, sizeof(struct sockaddr_in)); | |
| 356 httpstate.server_conn.sin_family = AF_INET; | |
| 357 httpstate.server_conn.sin_addr.s_addr = INADDR_ANY; | |
| 358 httpstate.server_conn.sin_port = htons(CYGNUM_NET_ATHTTPD_SERVEROPT_PORT); | |
| 359 rc = bind(listener, | |
| 360 (struct sockaddr *)&httpstate.server_conn, | |
| 361 sizeof(struct sockaddr)); | |
| 362 CYG_ASSERT(rc == 0, "bind() returned error"); | |
| 363 if (rc != 0) | |
| 364 return; | |
| 365 | |
| 366 rc = listen(listener, SOMAXCONN); | |
| 367 CYG_ASSERT(rc == 0, "listen() returned error"); | |
| 368 if (rc != 0) | |
| 369 return; | |
| 370 | |
| 371 diag_printf("Web server Started and listening...\n"); | |
| 372 cyg_int32 i; | |
| 373 for (i = 0; i < CYGNUM_FILEIO_NFILE; i++) | |
| 374 { | |
| 375 httpstate.sockets[i].descriptor = 0; | |
| 376 httpstate.sockets[i].timestamp = (time_t)0; | |
| 377 } | |
| 378 | |
| 379 FD_ZERO(&httpstate.rfds); | |
| 380 httpstate.fdmax = listener; | |
| 381 while (1) | |
| 382 { | |
| 383 FD_SET(listener, &httpstate.rfds); | |
| 384 struct timeval tv = {CYG_HTTPD_SOCKET_IDLE_TIMEOUT, 0}; | |
| 385 rc = select(httpstate.fdmax + 1, &httpstate.rfds, NULL, NULL, &tv); | |
| 386 if (rc > 0) | |
| 387 { | |
| 388 if (FD_ISSET(listener, &httpstate.rfds)) | |
| 389 // If the request is from the listener socket, then | |
| 390 // this must be a new connection. | |
| 391 cyg_httpd_handle_new_connection(listener); | |
| 392 | |
| 393 httpstate.fdmax = listener; | |
| 394 for (i = 0; i < CYGPKG_NET_MAXSOCKETS; i ++) | |
| 395 { | |
| 396 cyg_int32 descr = httpstate.sockets[i].descriptor; | |
| 397 if (descr != 0) | |
| 398 { | |
| 399 // If the descriptor is set in the descriptor list, we | |
| 400 // service it. Otherwise, we add it to the descriptor list | |
| 401 // to listen for. The rfds list gets rewritten each time | |
| 402 // select() is called and after the call it contains only | |
| 403 // the descriptors that need be serviced. Before calling | |
| 404 // select() again we must repopulate the list with all the | |
| 405 // descriptors that must be listened for. | |
| 406 if (FD_ISSET(descr, &httpstate.rfds)) | |
| 407 cyg_httpd_process_request(i); | |
| 408 else | |
| 409 FD_SET(descr, &httpstate.rfds); | |
| 410 httpstate.fdmax = MAX(httpstate.fdmax, descr); | |
| 411 } | |
| 412 } | |
| 413 } | |
| 414 else if (rc == 0) | |
| 415 { | |
| 416 cyg_httpd_close_unused_sockets(listener); | |
| 417 } | |
| 418 else | |
| 419 { | |
| 420 perror("error"); | |
| 421 cyg_int8 *ptr = (cyg_int8*)&httpstate.rfds; | |
| 422 printf("rfds: %x %x %x %x\n", ptr[0], ptr[1], ptr[2], ptr[3] ); | |
| 423 for (i = 0; i < CYGPKG_NET_MAXSOCKETS; i++) | |
| 424 if (httpstate.sockets[i].descriptor != 0) | |
| 425 diag_printf("Socket in list: %d\n", | |
| 426 httpstate.sockets[i].descriptor); | |
| 427 CYG_ASSERT(rc != -1, "Error during select()"); | |
| 428 } | |
| 429 } | |
| 430 } | |
| 431 | |
| 432 void | |
| 433 cyg_httpd_start(void) | |
| 434 { | |
| 435 if (cyg_httpd_initialized) | |
| 436 return; | |
| 437 cyg_httpd_initialized = 1; | |
| 438 | |
| 439 cyg_thread_create(CYGNUM_NET_ATHTTPD_THREADOPT_PRIORITY, | |
| 440 cyg_httpd_daemon, | |
| 441 (cyg_addrword_t)0, | |
| 442 "HTTPD Thread", | |
| 443 (void *)cyg_httpd_thread_stack, | |
| 444 CYG_HTTPD_DAEMON_STACK_SIZE, | |
| 445 &cyg_httpd_thread_handle, | |
| 446 &cyg_httpd_thread_object); | |
| 447 cyg_thread_resume(cyg_httpd_thread_handle); | |
| 448 } | |
| 449 | |
| 450 | |
| 451 |