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);
}
