void rtsmb_net_set_ip (PFBYTE host_ip, PFBYTE mask_ip) { int i; byte rtsmb_net_mask_ip [4]; if (host_ip) { rtp_memcpy (rtsmb_net_host_ip, host_ip, 4); } else { rtp_memcpy (rtsmb_net_host_ip, rtsmb_net_default_host_ip, 4); } if (mask_ip) { rtp_memcpy (rtsmb_net_mask_ip, mask_ip, 4); } else { rtp_memcpy (rtsmb_net_mask_ip, rtsmb_net_default_mask_ip, 4); } for (i = 0; i < 4; i++) { rtsmb_net_broadcast_ip[i] = (rtsmb_net_mask_ip[i] & rtsmb_net_host_ip[i]) | (byte)~(rtsmb_net_mask_ip[i]); } rtsmb_net_ip_is_set = TRUE; }
/* ******************************************************************** open the loop back driver interface. This routine opens a loop back device driver The address of this function must be placed into the "devices" table in iface.c either at compile time or before a device open is called. ******************************************************************** */ RTP_BOOL loop_open(PIFACE pi) { NATIVE_PROFILE_HAL_DRIVERS_ETHERNET(); /* say interface structure so xmit knows where to find it */ loop_pi = pi; /* Now put in a dummy ethernet address Get the ethernet address */ rtp_memcpy(pi->addr.my_hw_addr, phony_addr, ETH_ALEN); /* clear statistic information */ loop_packets_in = 0L; loop_packets_out = 0L; loop_bytes_in = 0L; loop_bytes_out = 0L; loop_errors_in = 0L; loop_errors_out = 0L; rtp_irq_hook_interrupt( (RTP_PFVOID) pi, (RTP_IRQ_FN_POINTER)loop_interrupt, (RTP_IRQ_FN_POINTER) 0); return(RTP_TRUE); }
/*---------------------------------------------------------------------------*/ char * _rtp_strdup (const char *str) { long len = (rtp_strlen(str) + 1) * sizeof(char); char *s = (char *) rtp_malloc(len); if (s) { rtp_memcpy(s, str, len); } return (s); }
char * _rtp_debug_strdup (const char *str, const char *file, long line) { long len = (rtp_strlen(str) + 1) * sizeof(char); char *s = (char *) _rtp_debug_malloc(len, _rtp_malloc, file, line); if (s) { rtp_memcpy(s, str, len); } return (s); }
/*---------------------------------------------------------------------------*/ static void _rtp_pbuf_ctx_add (RTP_PBUF_CTX* pbufCtx, RTP_PBUF_RESOURCE* resource) { RTP_PBUF_RESOURCE tempResource; unsigned long totalElementSize; unsigned long padding; rtp_memcpy(&tempResource, resource, sizeof(RTP_PBUF_RESOURCE)); resource->numElements = 0; resource->next = 0; for (;;) { while (((unsigned long)(tempResource.mem) & (sizeof(void*)-1)) && tempResource.size) { /* ----------------------------------- */ /* Alligning available resource pool */ /* for worst case pointer alignement. */ /* ----------------------------------- */ (unsigned long)(tempResource.mem) = (unsigned long)(tempResource.mem) + 1; tempResource.size--; } /* ----------------------------------- */ /* Padding is equal to the sum of the */ /* element structure size and a void* */ /* to the start of the element plus */ /* any additional padding need to */ /* align the data area with the list */ /* alignment requirement. */ /* ----------------------------------- */ padding = sizeof(RTP_PBUF_ELEMENT) + RTP_PBUF_ELEMENT_START_OFFSET; while (((unsigned long)(tempResource.mem) + padding) & (pbufCtx->alignment - 1)) { padding++; } totalElementSize = padding + pbufCtx->elementSize; if (tempResource.size >= totalElementSize) { void* temp; ((RTP_PBUF_ELEMENT*)(tempResource.mem))->elementOwner = pbufCtx; ((RTP_PBUF_ELEMENT*)(tempResource.mem))->listOwner = pbufCtx; ((RTP_PBUF_ELEMENT*)(tempResource.mem))->next = pbufCtx->firstElement; pbufCtx->firstElement = ((RTP_PBUF_ELEMENT*)(tempResource.mem)); ((RTP_PBUF_ELEMENT*)(tempResource.mem))->data = (void*) (((unsigned long)tempResource.mem) + padding); #ifdef RTP_TRACK_PACKET_BUFFER ((RTP_PBUF_ELEMENT*)(tempResource.mem))->tracker = (void*)0; #endif #ifdef RTP_TRACE_PACKET_BUFFER ((RTP_PBUF_ELEMENT*)(tempResource.mem))->tracer = (void*)0; #endif temp = (void*) (((unsigned long)((RTP_PBUF_ELEMENT*)(tempResource.mem))->data) - RTP_PBUF_ELEMENT_START_OFFSET); tempResource.mem = (void*) (((unsigned long)tempResource.mem) + totalElementSize); tempResource.size -= totalElementSize; resource->numElements++; pbufCtx->elementsAlloced++; pbufCtx->elementsAvailable++; } else { resource->next = pbufCtx->firstResource; pbufCtx->firstResource = resource; return; } } }
RTP_BOOL SH7264_SMSC_open(PIFACE pi) { DWORD mac[2], dwCnt, dwReg, dw; PSH7264_SMSC_SOFTC sc = iface_to_softc(pi); if (!sc) { RTP_DEBUG_ERROR("SH7264_SMSC_open: softc invalid!\r\n", NOVAR, 0, 0); set_errno(ENUMDEVICE); return(RTP_FALSE); } // Set Interface sc->iface = pi; iface = pi; //Setting port PJCR0 |= 0x3300; if (WORD_SWAP != 0xFFFFFFFF) //Need at least one read from LAN chip before writing to WORD_SWAP register { WORD_SWAP = 0xFFFFFFFF; } ETHERNET_DELAY(10000); // soft reset HW_CFG = HWCFG_SRST; dwCnt = 100000; do { ETHERNET_DELAY(10); dwReg = HW_CFG; dwCnt--; }while ((dwCnt > 0) && (dwReg & HWCFG_SRST)); if (dwReg & HWCFG_SRST) { debug_printf("SH7264_SMSC_open: Error in Soft reset.\r\n"); return; } ETHERNET_DELAY(10000); //Read Mac address from EEPROM mac[0] = BIT_EDIANDW(SMSC9218_Read_Mac_Reg(ADDRL)); mac[1] = BIT_EDIANDW(SMSC9218_Read_Mac_Reg(ADDRH)); int macLen = __min(g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7264RSK].macAddressLen, sizeof(sc->mac_address)); dw = (DWORD)&g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7264RSK].macAddressBuffer[0]; if (((dw >= 0x00000000) && (dw <= 0x03000000)) || ((dw >= 0x20000000) && (dw <= 0x23000000))) { g_AM29DL_16_BS_DeviceTable.InitializeDevice(pBLOCK_CONFIG); g_AM29DL_16_BS_DeviceTable.Write(pBLOCK_CONFIG,(DWORD)&g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7264RSK].macAddressBuffer[0],6,(BYTE *)mac,TRUE); } else { memcpy((void *)&g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7264RSK].macAddressBuffer[0], (void *)&mac[0], 6); } if(macLen > 0) { memcpy(&sc->mac_address[0], &g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7264RSK].macAddressBuffer[0], macLen); } else { RTP_DEBUG_ERROR("Device initialize without MAC address!!!\r\n", NOVAR, 0, 0); } // Now put in a dummy ethernet address rtp_memcpy(&pi->addr.my_hw_addr[0], sc->mac_address, 6); // Get the ethernet address // clear statistic information sc->stats.packets_in = 0L; sc->stats.packets_out = 0L; sc->stats.bytes_in = 0L; sc->stats.bytes_out = 0L; sc->stats.errors_in = 0L; sc->stats.errors_out = 0L; if(RTP_FALSE == SH7264_SMSC_SetupDevice()) { return RTP_FALSE; } rtp_irq_hook_interrupt( (RTP_PFVOID) pi, (RTP_IRQ_FN_POINTER)SH7264_SMSC_recv, (RTP_IRQ_FN_POINTER) 0); return(RTP_TRUE); }
// ---------------------------------------------------- // ENTRY POINT // ---------------------------------------------------- int smbservermain(void) { char c; int go; int have_printer; byte security_mode; RTP_THREAD new_thread; #ifndef RTSMB_RTIP int spinState = 0; char spinner[4] = {'\\', '-', '/', '|'}; #endif // ------------------------------------------------ #if (INCLUDE_RTIP) rtp_memcpy(my_ip_srv_address, my_ip_address, IP_ALEN); rtp_memcpy(ip_srv_mask_address, ip_mask_address, IP_ALEN); #endif // ------------------------------------------------ rtp_printf("\n\nRun Alt Port Numbers(Y/y) or Well-Known(N/n)"); while (!kbhit ()) { } c = getch (); if (c == 'Y' || c == 'y') { rtsmb_init_port_alt (); } if (c == 'N' || c == 'n') { rtsmb_init_port_well_know (); } // ------------------------------------------------ if (!rtp_file_mkdir (SHARE_PATH)) { rtp_printf("WARNING: mkdir of SHARE_PATH failed %s\n", SHARE_PATH, 0); } rtp_printf("\nsmbservermain - enter\n"); go = 1; /* Start ertfs on windows*/ //pc_ertfs_init (); /* initialize server */ rtsmb_srv_init (my_ip_srv_address, ip_srv_mask_address, NETWORK_NAME , NETWORK_GROUP); rtp_printf ("Initialized rtsmb\n"); #ifdef USE_CONFIG_FILE rtsmb_srv_read_config ("smb_config.txt"); #else rtp_printf("Note: The demo does not actually print data, it just captures print data to a temporary file.\n"); { char printerName[32]; char driverName[32]; char tempPath[32]; char prnFile[32]; rtp_strcpy(printerName, "SmbPrinter"); rtp_strcpy(driverName, "HP LaserJet 1100"); rtp_strcpy(tempPath, TEMP_PATH); rtp_strcpy(prnFile, "SmbPrintData.prn"); have_printer = in_printer(printerName,driverName, tempPath, prnFile); if (have_printer) { rtsmb_srv_share_add_printer (printerName, driverName, 1, (PSMBFILEAPI)0, tempPath, 0, (PFCHAR)0, prnFile); } } security_mode = in_loginmode(); //rtsmb_srv_share_add_tree (SHARE_NAME, DESCRIPTION, NULL, SHARE_PATH, SHARE_FLAGS_8_3, SECURITY_READWRITE, NULL); //rtsmb_srv_share_add_tree (SHARE_NAME, DESCRIPTION, (PSMBFILEAPI)0, SHARE_PATH, SHARE_FLAGS_CREATE, SECURITY_READWRITE, (PFCHAR)0); rtsmb_srv_share_add_ipc ((PFCHAR)0); rtsmb_srv_set_mode (security_mode); /* AUTH_USER_MODE or AUTH_SHARE_MODE */ rtsmb_srv_register_group ("rw_access"); rtsmb_srv_register_group ("rd_access"); { char shareName[32]; char sharePath[32]; char shareDesc[32]; char sharePass[32]; char secCode[32]; rtp_strcpy(shareName, SHARE_NAME); rtp_strcpy(shareDesc, "Rtsmbshare"); rtp_strcpy(sharePath, SHARE_PATH); rtp_strcpy(sharePass, ""); rtp_strcpy(secCode,"2"); if (in_share(security_mode, shareName, sharePath, shareDesc, sharePass, secCode)) { byte security_mode; /* Defult is 2 SECURITY_READWRITE */ char *psharePass; if (sharePass[0]) psharePass = &sharePass[0]; else psharePass = 0; security_mode = (byte)(secCode[0] -'0'); rtsmb_srv_share_add_tree (shareName, shareDesc, (PSMBFILEAPI)0, sharePath, SHARE_FLAGS_CREATE, security_mode, (PFCHAR)psharePass); rtsmb_srv_set_group_permissions ("rw_access", shareName, SECURITY_READWRITE); rtsmb_srv_set_group_permissions ("rd_access", shareName, SECURITY_READ); } } // rtsmb_srv_set_group_permissions ("rw_access", SHARE_NAME, SECURITY_READWRITE); rtsmb_srv_set_group_permissions ("rw_access", "IPC$", SECURITY_READWRITE); rtsmb_srv_set_group_permissions ("rd_access", "IPC$", SECURITY_READWRITE); //rtsmb_srv_register_group ("ro_access"); //rtsmb_srv_set_group_permissions ("ro_access", SHARE_NAME, SECURITY_READ); //rtsmb_srv_set_group_permissions ("ro_access", "IPC$", SECURITY_READWRITE); //rtsmb_srv_register_group ("wo_access"); //rtsmb_srv_set_group_permissions ("wo_access", SHARE_NAME, SECURITY_WRITE); //rtsmb_srv_set_group_permissions ("wo_access", "IPC$", SECURITY_READWRITE); /* No access */ //rtsmb_srv_register_group ("nonebs"); //rtsmb_srv_set_group_permissions ("nonebs", SHARE_NAME, SECURITY_NONE); //rtsmb_srv_set_group_permissions ("nonebs", "IPC$", SECURITY_NONE); //rtsmb_srv_register_user (SMB_GUESTNAME, (PFCHAR)0); //rtsmb_srv_register_user (SMB_GUESTNAME, "ebs"); //rtsmb_srv_add_user_to_group (SMB_GUESTNAME, "rw_access"); if (security_mode == AUTH_USER_MODE) { char userName[32]; char userPass[32]; char userPerm[32]; if (in_guestaccount()) rtsmb_srv_register_user (SMB_GUESTNAME, (PFCHAR)0); rtp_strcpy(userName, "user"); rtp_strcpy(userPass, "password"); rtp_printf("Add users, enter a blank user to stop : "); while (in_user(userName, userPass, userPerm)) { rtsmb_srv_register_user (userName, userPass); if (rtp_strcmp(userPerm, "rw") == 0) {rtsmb_srv_add_user_to_group (userName, "rw_access");break;} else if (rtp_strcmp(userPerm, "r") == 0) {rtsmb_srv_add_user_to_group (userName, "rd_access");break;} } } #endif //USE_CONFIG_FILE #if (1) if (rtp_thread_spawn ( &new_thread, (RTP_ENTRY_POINT_FN) rtsmb_main, (const char *) "RTIP_SMB_SRV", STACKSIZE_HUGE_INDEX, TASKPRIO_NORMAL_INDEX, (void *) 0 ) < 0) { rtp_term_puts("spawn of SMB task failed"); return(-1); } rtp_term_puts("spawn of SMB task WORKED"); while (1) { #ifndef RTSMB_RTIP spinState += 1; spinState = spinState%4; rtp_printf("\b%c",spinner[spinState]); #endif rtsmb_srv_cycle (1000); } #else //Main Loop while(go) { rtsmb_main (); if(rtp_term_kbhit()) { // switch (getch()) switch (rtp_term_getch()) { case 'q': go = 0; break; default: break; } } } //Shutdown rtp_printf("main: shutting down\n"); rtsmb_srv_shutdown (); rtp_net_exit (); #endif return(0); }//main
wcEL wcELFind (wcCtx* Ctx, wcEL El, char *Domstr, wcBOOL *pError) { wcEL current; char *p; int isRoot = 0; *pError = wcFALSE; p = Domstr; current = El; if (*p == '/') { current = 0; isRoot = 1; p++; } else { current = El; if (!current) *pError = wcTRUE; } while (*p && (current || isRoot)) { enum DomTraverseResult opcode; int nChars; opcode = _ParseNextExpression(p, &nChars); // Find first and find is the only legal operation on the root if (isRoot && (opcode!=DomFind && opcode!=DomFirstChild)) { *pError = wcTRUE; return current; } switch (opcode) { case DomFind: { char findBuffer[MAXIDSIZE+1]; if (nChars > MAXIDSIZE) nChars = MAXIDSIZE; rtp_memcpy(findBuffer,p,nChars); findBuffer[nChars] = 0; if (isRoot) current = _FindElementInRoot(Ctx,findBuffer); else current = _FindElementById(Ctx,current,findBuffer); } break; case DomSelf: current = current; break; case DomParent: current = _FindParentElement(Ctx,current); break; case DomFirstChild: if (isRoot) current = _FindFirstChildInRoot(Ctx); else current = _FindFirstChild(Ctx,current); break; case DomLastChild: current = _FindLastChild(Ctx,current); break; case DomPrevSibling: current = _FindPrevSibling(Ctx,current); break; case DomNextSibling: current = _FindNextSibling(Ctx,current); break; case DomError: default: *pError = wcTRUE; current = 0; break; } p+= nChars; if (*(p) == '/') p++; else if (*(p) != '\0') { *pError = wcTRUE; current = 0; } isRoot = 0; } return current; }
RTP_BOOL SH7619_EDMAC_open(PIFACE pi) { PSH7619_EDMAC_SOFTC sc = iface_to_softc(pi); char c[1],Buffer[17]; int i; UINT32 Events; BYTE Buff[6]; if (!sc) { RTP_DEBUG_ERROR("SH7619_EDMAC_open: softc invalid!\r\n", NOVAR, 0, 0); set_errno(ENUMDEVICE); return(RTP_FALSE); } // Set Interface sc->iface = pi; iface = pi; int macLen = __min(g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressLen, sizeof(sc->mac_address)); if(macLen > 0) { int addr = MAC_address_area; for(i=0; i<macLen; i++) g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[i] = *(volatile char *)(addr+i); debug_printf( "MAC Address: %x.%x.%x.%x.%x.%x\r\n", (UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[0], (UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[1], (UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[2], (UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[3], (UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[4], (UINT8)g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[5]); debug_printf( "Do you need to change MAC Address? If yes, press 'Enter' key\r\n" ); c[0] = 0x0; for (i=0; i<0xff; i++){ DebuggerPort_Read( HalSystemConfig.DebugTextPort, c, 1); if (c[0] == 0x0d){ hal_printf( "new MAC Address :" ); while(c[0] == 0x0d) DebuggerPort_Read( HalSystemConfig.DebugTextPort, c, 1); for(i=0; i<17; ){ Events = Events_WaitForEvents( SYSTEM_EVENT_FLAG_COM_IN, 100 ); if(Events & SYSTEM_EVENT_FLAG_COM_IN){ Events_Clear( SYSTEM_EVENT_FLAG_COM_IN ); DebuggerPort_Read( HalSystemConfig.DebugTextPort, c, 1); Buffer[i] = c[0]; i++; } } for (i=0; i<17; i++) hal_printf( "%c",Buffer[i] ); hal_printf( "\r\n"); for(i=0; i<macLen; i++) { Buff[i]=SH7619_EDMAC_AtoH(Buffer[i*3])*0x10; Buff[i]+=SH7619_EDMAC_AtoH(Buffer[i*3+1]); } for(i=0; i<macLen; i++) { g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[i]=Buff[i]; } debug_printf( "Updating...\r\n" ); g_AM29DL_16_BS_DeviceTable.InitializeDevice(pBLOCK_CONFIG); g_AM29DL_16_BS_DeviceTable.EraseBlock(pBLOCK_CONFIG,MAC_address_area); g_AM29DL_16_BS_DeviceTable.Write(pBLOCK_CONFIG,MAC_address_area,macLen,Buff,0x0); debug_printf( "Done\r\n" ); i=0x100; } } memcpy(&sc->mac_address[0], &g_NetworkConfig.NetworkInterfaces[NETWORK_INTERFACE_INDEX_SH7619EMAC].macAddressBuffer[0], macLen); } else { RTP_DEBUG_ERROR("Device initialize without MAC address!!!\r\n", NOVAR, 0, 0); } /* Now put in a dummy ethernet address */ rtp_memcpy(&pi->addr.my_hw_addr[0], sc->mac_address, 6); // Get the ethernet address /* clear statistic information */ sc->stats.packets_in = 0L; sc->stats.packets_out = 0L; sc->stats.bytes_in = 0L; sc->stats.bytes_out = 0L; sc->stats.errors_in = 0L; sc->stats.errors_out = 0L; if(RTP_FALSE == SH7619_EDMAC_SetupDevice()) { return RTP_FALSE; } rtp_irq_hook_interrupt( (RTP_PFVOID) pi, (RTP_IRQ_FN_POINTER)SH7619_EDMAC_recv, (RTP_IRQ_FN_POINTER) 0); return(RTP_TRUE); }
int HTTP_ServerInit (HTTPServerContext *server, /** pointer to uninitialized \Ref{HTTPServerContext} struct */ const HTTP_CHAR *name, /** Server name. Sent in HTTP header. */ const HTTP_CHAR *rootDir, /** Path to the root directory for content. */ const HTTP_CHAR *defaultFile, /** Default Filename if "\" or "path\" is passed with no file name. */ HTTP_INT8 httpMajorVersion, /** Normally 1 for HTTP 1.1 */ HTTP_INT8 httpMinorVersion, /** Normally 1 for HTTP 1.1 */ HTTP_UINT8 *ipAddr, /** V4/V6 examples: ipaddr[4] = {192, 168, 0, 6}; ipAddr = "fe80::20b:dbff:fe2f:c162"; */ HTTP_INT16 port, /** port number (80) usually */ HTTP_INT16 ipType, /** ipversion 4 or 6 */ HTTP_BOOL allowKeepAlive, /** If HTTP version < 1.1 enables keep-alive support. For 1,1 and greater keep-alive is the default.*/ HTTPServerConnection* connectCtxArray, /** pointer to uninitialized bytes, must be (sizeof(HTTPServerConnection) * maxConnections)) bytes. */ HTTP_INT16 maxConnections, /** The maximum limit on simultaneous HTTP server connections */ HTTP_INT16 maxHelperThreads /** If HTTP_SERVER_MULTITHREAD is defined, the max number of helper threads to spawn */ ) { rtp_memset((unsigned char *) server, 0, sizeof(HTTPServerContext)); if (rtp_net_socket_stream_dual(&server->serverSocket, ipType) >= 0) { if (rtp_net_bind_dual(server->serverSocket, RTP_NET_STREAM, ipAddr, port, ipType) >= 0 && rtp_net_listen(server->serverSocket, maxConnections) >= 0) { if (!ipAddr) { if (rtp_net_getsockname(server->serverSocket, server->serverAddress.ipAddr, &server->serverAddress.port, &server->serverAddress.type) < 0) { rtp_memset(server->serverAddress.ipAddr, 0, RTP_NET_IP_ALEN); } } else { rtp_memcpy(server->serverAddress.ipAddr, ipAddr, RTP_NET_IP_ALEN); server->serverAddress.port = port; } if (name) { rtp_strncpy(server->serverName, name, HTTP_SERVER_NAME_LEN-1); } else { rtp_strncpy(server->serverName, HTTP_SERVER_NAME_STRING, HTTP_SERVER_NAME_LEN-1); } server->httpMajorVersion = httpMajorVersion; server->httpMinorVersion = httpMinorVersion; if (rootDir) { rtp_strncpy(server->rootDir, rootDir, HTTP_SERVER_PATH_LEN-1); } else { /* default to the current working directory */ server->rootDir[0] = '.'; server->rootDir[1] = 0; } if (defaultFile) { rtp_strncpy(server->defaultFile, defaultFile, HTTP_SERVER_DEFAULT_FILE_LEN-1); } else { rtp_strncpy(server->defaultFile, HTTP_SERVER_DEFAULT_FILE, HTTP_SERVER_DEFAULT_FILE_LEN-1); } if (!allowKeepAlive || (server->httpMajorVersion == 1 && server->httpMinorVersion > 0) || (server->httpMajorVersion > 1)) { server->allowKeepAlive = allowKeepAlive; server->maxConnections = maxConnections; DLLIST_INIT(&server->pathList); DLLIST_INIT(&server->realmList); server->allowedClientList = 0; server->numAllowedClients = 0; server->blockedClientList = 0; server->numBlockedClients = 0; #ifdef HTTP_SERVER_KEEP_ALIVE DLLIST_INIT(&server->openConnections); #endif /* HTTP_SERVER_KEEP_ALIVE */ #ifdef HTTP_SERVER_MULTITHREAD server->connectionContextArray = connectCtxArray; server->maxHelperThreads = maxHelperThreads; /* allocate the server lock */ if (rtp_sig_mutex_alloc(&server->lock, 0) >= 0) { RTP_MUTEX helperThreadMutex; RTP_SEMAPHORE helperThreadSemaphore; /* initialize the session queue */ if (rtp_sig_mutex_alloc(&helperThreadMutex, 0) >= 0) { if (rtp_sig_semaphore_alloc(&helperThreadSemaphore, 0) >= 0) { if (rtp_helper_thread_ctx_init ( &server->helperContext, helperThreadMutex, helperThreadSemaphore ) >= 0) { int n; // initialize the free job list server->jobFreeList = connectCtxArray; for (n = 0; n < maxConnections-1; n++) { connectCtxArray[n].job.next = &(connectCtxArray[n+1].job); connectCtxArray[n].job.execute = _HTTP_ServerExecuteJob; connectCtxArray[n].server = server; } connectCtxArray[n].job.next = 0; connectCtxArray[n].job.execute = _HTTP_ServerExecuteJob; connectCtxArray[n].server = server; server->status = HTTP_SERVER_INITIALIZED; return (0); } rtp_sig_semaphore_free(helperThreadSemaphore); } rtp_sig_mutex_free(helperThreadMutex); } rtp_sig_mutex_free(server->lock); } #else /* HTTP_SERVER_MULTITHREAD */ //server->queueFirst = 0; //server->queueLast = 0; server->status = HTTP_SERVER_INITIALIZED; return (0); #endif /* HTTP_SERVER_MULTITHREAD */ } } rtp_net_closesocket(server->serverSocket); } return (-1); }
/*---------------------------------------------------------------------------*/ static int __HTTP_ServerHandleRequest (HTTPServerRequestContext *ctx, HTTPSession *session, HTTPRequest *request, RTP_NET_ADDR *clientAddr, HTTPVirtualFileInfo *vfile) { HTTP_CHAR fsPath[HTTP_SERVER_PATH_LEN]; HTTPServerContext *server = ctx->server; switch (request->methodType) { case HTTP_METHOD_GET: { HTTPResponse response; RTP_FILE fd; HTTP_INT32 bytesRead, bufferSize = 1024; HTTP_INT32 bytesleft=0; HTTP_UINT8 buffer[1024]; FileContentType contentType; unsigned chunked = 0; unsigned found = 0; const HTTP_UINT8 *pdata; if (vfile) { pdata=vfile->data; bytesleft = vfile->size; } if (vfile) { HTTP_ServerReadHeaders( ctx, session, _HTTP_VirtualFileProcessHeader, 0, buffer, bufferSize ); found = 1; } else { _HTTP_ServerReadHeaders(ctx, session, 0, 0, buffer, bufferSize); _HTTP_ConstructLocalPath(server, fsPath, (HTTP_CHAR *) request->target, HTTP_SERVER_PATH_LEN); if (rtp_file_open(&fd, fsPath, RTP_FILE_O_BINARY|RTP_FILE_O_RDONLY, RTP_FILE_S_IREAD) < 0) { if ((server->defaultFile) && (server->defaultFile[0]) && (fsPath[0]=='\0'||(fsPath[rtp_strlen(fsPath)-1] == '\\') || (fsPath[rtp_strlen(fsPath)-1] == '/'))) { if ((HTTP_SERVER_PATH_LEN - rtp_strlen(server->defaultFile)) > rtp_strlen(server->defaultFile)) { rtp_strcat(fsPath, server->defaultFile); if (rtp_file_open(&fd, fsPath, RTP_FILE_O_BINARY|RTP_FILE_O_RDONLY, RTP_FILE_S_IREAD) >= 0) { found = 1; } } } } else found = 1; } if (!found) { _HTTP_ServerSendError(ctx, session, 404, "Not Found"); return (0); } _HTTP_ServerInitResponse(ctx, session, &response, 200, "OK"); _HTTP_ServerSetDefaultHeaders(ctx, &response); if (vfile) { HTTP_SetResponseHeaderStr(&response, "Content-Type", vfile->contentType); if (vfile->contentEncoding) { HTTP_SetResponseHeaderStr(&response, "Content-Encoding", vfile->contentEncoding); } HTTP_SetResponseHeaderTime(&response, "Last-Modified", &vfile->creationTime); } else { contentType = GetFileTypeByExtension(fsPath); if (contentType != FILE_TYPE_UNKNOWN) { HTTP_SetResponseHeaderStr(&response, "Content-Type", FileContentTypeToStr(contentType)); } } if (ctx->keepAlive) { if (request->httpMajorVersion > 1 || (request->httpMajorVersion == 1 && request->httpMinorVersion >= 1)) { HTTP_SetResponseHeaderStr(&response, "Transfer-Encoding", "chunked"); chunked = 1; } else { void* dirobj; unsigned long fileSize; if (vfile) { fileSize = vfile->size; } else { if (rtp_file_gfirst(&dirobj, fsPath) < 0) { _HTTP_ServerSendError(ctx, session, 500, "Internal Server Error"); HTTP_FreeResponse(&response); rtp_file_close(fd); return (-1); } if (rtp_file_get_size(dirobj, &fileSize) < 0) { _HTTP_ServerSendError(ctx, session, 500, "Internal Server Error"); HTTP_FreeResponse(&response); rtp_file_gdone(dirobj); rtp_file_close(fd); return (-1); } rtp_file_gdone(dirobj); } HTTP_SetResponseHeaderInt(&response, "Content-Length", fileSize); } } HTTP_WriteResponse(session, &response); HTTP_FreeResponse(&response); do { #define EBSMIN(X,Y) ((X)<(Y)?(X):(Y)) if (vfile) { bytesRead=EBSMIN(bufferSize,bytesleft); rtp_memcpy(buffer,pdata,bytesRead); bytesleft -= bytesRead; pdata += bytesRead; } else bytesRead = rtp_file_read(fd, buffer, bufferSize); if (bytesRead > 0) { if (chunked) { if (HTTP_WriteChunkStart(session, bytesRead) < 0) { break; } } if (HTTP_Write(session, buffer, bytesRead) < bytesRead) { break; } if (chunked) { if (HTTP_WriteChunkEnd(session) < 0) { break; } } } } while (bytesRead > 0); /* this tells the client the transfer is complete */ if (chunked) { HTTP_WriteChunkStart(session, 0); HTTP_WriteChunkEnd(session); } HTTP_WriteFlush(session); if (!vfile) rtp_file_close(fd); break; } default: break; } return (0); }