/*-----------------------------------------------------------------------------------*/
void
uip_arp_arpin(void)
{
if(uip_len < sizeof(struct arp_hdr)) {
uip_len = 0;
return;
}
uip_len = 0;
switch(BUF->opcode) {
case HTONS(ARP_HINT):
/* Please note this is not a valid ARP type, this is just a
* hint to implement prefetch/refresh of ARP mapping */
/* This is a valid hint if we are the source of this request,
* the requested ipaddr is in dipaddress */
if(uip_ipaddr_cmp(BUF->sipaddr, uip_hostaddr)) {
/* We first try to check for the destination address
* in our ARP table */
if(uip_arp_update(BUF->dipaddr, &broadcast_ethaddr)) {
/* If the destination address was not in our ARP table,
* we send out an ARP request for the same */
memset(BUF->ethhdr.dest.addr, 0xff, 6);
BUF->opcode = HTONS(ARP_REQUEST);
/* The other ARP fields of incoming hint are
* supposed to be same as ARP broadcast except
* the opcode field */
uip_len = sizeof(struct arp_hdr);
}
}
break;
case HTONS(ARP_REQUEST):
/* ARP request. If it asked for our address, we send out a
reply. */
if(uip_ipaddr_cmp(BUF->dipaddr, uip_hostaddr)) {
/* First, we register the one who made the request in our ARP
table, since it is likely that we will do more communication
with this host in the future. */
uip_arp_update(BUF->sipaddr, &BUF->shwaddr);
BUF->opcode = HTONS(ARP_REPLY);
memcpy(BUF->dhwaddr.addr, BUF->shwaddr.addr, 6);
memcpy(BUF->shwaddr.addr, uip_ethaddr.addr, 6);
memcpy(BUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
memcpy(BUF->ethhdr.dest.addr, BUF->dhwaddr.addr, 6);
BUF->dipaddr[0] = BUF->sipaddr[0];
BUF->dipaddr[1] = BUF->sipaddr[1];
BUF->sipaddr[0] = uip_hostaddr[0];
BUF->sipaddr[1] = uip_hostaddr[1];
BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP);
uip_len = sizeof(struct arp_hdr);
}
break;
case HTONS(ARP_REPLY):
/* ARP reply. We insert or update the ARP table if it was meant
for us. */
if(uip_ipaddr_cmp(BUF->dipaddr, uip_hostaddr)) {
uip_arp_update(BUF->sipaddr, &BUF->shwaddr);
vmm_completion_complete(&uip_arp_prefetch_done);
}
break;
}
return;
}
// called for http server app
void httpd_appcall(void){
struct fs_file fsfile;
unsigned int i;
switch(uip_conn->lport){
case HTONS(80):
// app state
hs = (struct httpd_state *)(uip_conn->appstate);
// closed connection
if(uip_closed()){
httpd_state_reset();
uip_close();
return;
}
// aborted connection or time out occured
if(uip_aborted() || uip_timedout()){
httpd_state_reset();
uip_abort();
return;
}
// if we are pooled
if(uip_poll()){
if(hs->count++ >= 100){
httpd_state_reset();
uip_abort();
}
return;
}
// new connection
if(uip_connected()){
httpd_state_reset();
return;
}
// new data in STATE_NONE
if(uip_newdata() && hs->state == STATE_NONE){
// GET or POST request?
if(uip_appdata[0] == ISO_G && uip_appdata[1] == ISO_E && uip_appdata[2] == ISO_T && (uip_appdata[3] == ISO_space || uip_appdata[3] == ISO_tab)){
hs->state = STATE_FILE_REQUEST;
} else if(uip_appdata[0] == ISO_P && uip_appdata[1] == ISO_O && uip_appdata[2] == ISO_S && uip_appdata[3] == ISO_T && (uip_appdata[4] == ISO_space || uip_appdata[4] == ISO_tab)){
hs->state = STATE_UPLOAD_REQUEST;
}
// anything else -> abort the connection!
if(hs->state == STATE_NONE){
httpd_state_reset();
uip_abort();
return;
}
// get file or firmware upload?
if(hs->state == STATE_FILE_REQUEST){
// we are looking for GET file name
for(i = 4; i < 30; i++){
if(uip_appdata[i] == ISO_space || uip_appdata[i] == ISO_cr || uip_appdata[i] == ISO_nl || uip_appdata[i] == ISO_tab){
uip_appdata[i] = 0;
i = 0;
break;
}
}
if(i != 0){
printf("## Error: request file name too long!\n");
httpd_state_reset();
uip_abort();
return;
}
printf("Request for: ");
printf("%s\n", &uip_appdata[4]);
// request for /
if(uip_appdata[4] == ISO_slash && uip_appdata[5] == 0){
fs_open(file_index_html.name, &fsfile);
} else {
// check if we have requested file
if(!fs_open((const char *)&uip_appdata[4], &fsfile)){
printf("## Error: file not found!\n");
fs_open(file_404_html.name, &fsfile);
}
}
hs->state = STATE_FILE_REQUEST;
hs->dataptr = (u8_t *)fsfile.data;
hs->upload = fsfile.len;
// send first (and maybe the last) chunk of data
uip_send(hs->dataptr, (hs->upload > uip_mss() ? uip_mss() : hs->upload));
return;
} else if(hs->state == STATE_UPLOAD_REQUEST){
char *start = NULL;
char *end = NULL;
// end bufor data with NULL
uip_appdata[uip_len] = '\0';
/*
* We got first packet with POST request
*
* Some browsers don't include first chunk of data in the first
* POST request packet (like Google Chrome, IE and Safari)!
* So we must now find two values:
* - Content-Length
* - boundary
* Headers with these values can be in any order!
* If we don't find these values in first packet, connection will be aborted!
*
*/
// Content-Length pos
start = (char *)strstr((char*)uip_appdata, "Content-Length:");
if(start){
start += sizeof("Content-Length:");
// find end of the line with "Content-Length:"
end = (char *)strstr(start, eol);
if(end){
hs->upload_total = atoi(start);
#ifdef DEBUG_UIP
printf("Expecting %d bytes in body request message\n", hs->upload_total);
#endif
} else {
printf("## Error: couldn't find \"Content-Length\"!\n");
httpd_state_reset();
uip_abort();
return;
}
} else {
printf("## Error: couldn't find \"Content-Length\"!\n");
httpd_state_reset();
uip_abort();
return;
}
// we don't support very small files (< 10 KB)
if(hs->upload_total < 10240){
printf("## Error: request for upload < 10 KB data!\n");
httpd_state_reset();
uip_abort();
return;
}
// boundary value
start = NULL;
end = NULL;
start = (char *)strstr((char *)uip_appdata, "boundary=");
if(start){
// move pointer over "boundary="
start += 9;
// find end of line with boundary value
end = (char *)strstr((char *)start, eol);
if(end){
// malloc space for boundary value + '--' and '\0'
boundary_value = (char*)malloc(end - start + 3);
if(boundary_value){
memcpy(&boundary_value[2], start, end - start);
// add -- at the begin and 0 at the end
boundary_value[0] = '-';
boundary_value[1] = '-';
boundary_value[end - start + 2] = 0;
#ifdef DEBUG_UIP
printf("Found boundary value: \"%s\"\n", boundary_value);
#endif
} else {
printf("## Error: couldn't allocate memory for boundary!\n");
httpd_state_reset();
uip_abort();
return;
}
} else {
printf("## Error: couldn't find boundary!\n");
httpd_state_reset();
uip_abort();
return;
}
} else {
printf("## Error: couldn't find boundary!\n");
httpd_state_reset();
uip_abort();
return;
}
/*
* OK, if we are here, it means that we found
* Content-Length and boundary values in headers
*
* We can now try to 'allocate memory' and
* find beginning of the data in first packet
*/
webfailsafe_data_pointer = (u8_t *)WEBFAILSAFE_UPLOAD_RAM_ADDRESS;
if(!webfailsafe_data_pointer){
printf("## Error: couldn't allocate RAM for data!\n");
httpd_state_reset();
uip_abort();
return;
} else {
printf("Data will be downloaded at 0x%X in RAM\n", WEBFAILSAFE_UPLOAD_RAM_ADDRESS);
}
if(httpd_findandstore_firstchunk()){
data_start_found = 1;
} else {
data_start_found = 0;
}
return;
} /* else if(hs->state == STATE_UPLOAD_REQUEST) */
} /* uip_newdata() && hs->state == STATE_NONE */
// if we got ACK from remote host
if(uip_acked()){
// if we are in STATE_FILE_REQUEST state
if(hs->state == STATE_FILE_REQUEST){
// data which we send last time was received (we got ACK)
// if we send everything last time -> gently close the connection
if(hs->upload <= uip_mss()){
// post upload completed?
if(webfailsafe_post_done){
if(!webfailsafe_upload_failed){
webfailsafe_ready_for_upgrade = 1;
}
webfailsafe_post_done = 0;
webfailsafe_upload_failed = 0;
}
httpd_state_reset();
uip_close();
return;
}
// otherwise, send another chunk of data
// last time we sent uip_conn->len size of data
hs->dataptr += uip_conn->len;
hs->upload -= uip_conn->len;
uip_send(hs->dataptr, (hs->upload > uip_mss() ? uip_mss() : hs->upload));
}
return;
}
// if we need to retransmit
if(uip_rexmit()){
// if we are in STATE_FILE_REQUEST state
if(hs->state == STATE_FILE_REQUEST){
// send again chunk of data without changing pointer and length of data left to send
uip_send(hs->dataptr, (hs->upload > uip_mss() ? uip_mss() : hs->upload));
}
return;
}
// if we got new data frome remote host
if(uip_newdata()){
// if we are in STATE_UPLOAD_REQUEST state
if(hs->state == STATE_UPLOAD_REQUEST){
// end bufor data with NULL
uip_appdata[uip_len] = '\0';
// do we have to find start of data?
if(!data_start_found){
if(!httpd_findandstore_firstchunk()){
printf("## Error: couldn't find start of data in next packet!\n");
httpd_state_reset();
uip_abort();
return;
} else {
data_start_found = 1;
}
return;
}
hs->upload += (unsigned int)uip_len;
if(!webfailsafe_upload_failed){
memcpy((void *)webfailsafe_data_pointer, (void *)uip_appdata, uip_len);
webfailsafe_data_pointer += uip_len;
}
httpd_download_progress();
// if we have collected all data
if(hs->upload >= hs->upload_total){
printf("\n\n");
// end of post upload
webfailsafe_post_done = 1;
NetBootFileXferSize = (ulong)hs->upload_total;
// which website will be returned
if(!webfailsafe_upload_failed){
fs_open(file_flashing_html.name, &fsfile);
} else {
fs_open(file_fail_html.name, &fsfile);
}
httpd_state_reset();
hs->state = STATE_FILE_REQUEST;
hs->dataptr = (u8_t *)fsfile.data;
hs->upload = fsfile.len;
uip_send(hs->dataptr, (hs->upload > uip_mss() ? uip_mss() : hs->upload));
}
}
return;
}
break;
default:
// we shouldn't get here... we are listening only on port 80
uip_abort();
break;
}
}
// Task for reactivision output processing
void vServoTask( void)
{
u16_t ripaddr[2];
portBASE_TYPE xStatus;
xTuioQueuePacket xValueRead;
xTuioQueuePacket xDistanceValue[6];
// Tracking Variables
short sPosX = 0;
short sPosY = 0;
short sDegreesX = servoMIN_DEGREES;
short sDegreesY = (servoMIN_DEGREES+servoMAX_DEGREES)/4;
vServo_ConfigurePwm(sDegreesX, sDegreesY);
sX = 0;
sY = 0;
sZ = 0;
// Uip connect
vTaskDelay(1000);
uip_ipaddr(ripaddr, 192,168,0,1);
uip_connect(ripaddr, HTONS(3000));
xTuioQueue = xQueueCreate(20, sizeof(xTuioQueuePacket));
vSemaphoreCreateBinary(xControlServo);
short sFlightPlanStage = servotaskFLIGHT_PLAN_1;
short sGoalPoint;
short sGoalCounter;
// Servo control loop
for (;;) {
//Read from TUIO queue.
xStatus = xQueueReceive(xTuioQueue, &xValueRead, 10); // Block task for 10ms when waiting for the Queue
if (xStatus == pdPASS) { // Process received value
// values are between 0 and 1
sPosX = (short) (xValueRead.position_x*100.0f);
sPosY = (short) (xValueRead.position_y*100.0f);
short sId = xValueRead.class_id-servoFIDUCIAL_SET;
// If the middle fiducial marker, track it with the camera
if (sId >= 0 && sId <= 5) {
// Remember, position is taken from TOP LEFT
if (sPosX < servoBOUNDING_BOX_MIN && sDegreesX < servoMAX_DEGREES) {
sDegreesX++;
} else if (sPosX > servoBOUNDING_BOX_MAX && sDegreesX > servoMIN_DEGREES) {
sDegreesX--;
}
if (sPosY < servoBOUNDING_BOX_MIN && sDegreesY < servoMAX_DEGREES) {
sDegreesY++;
} else if (sPosY > servoBOUNDING_BOX_MAX && sDegreesY > servoMIN_DEGREES) {
sDegreesY--;
}
// Set the fiducial to being used, and the value to the current packet
sDistanceUsed[sId] = 1;
xDistanceValue[sId] = xValueRead;
// If there is an ID to compare to, calculate distance
if (sGetId(sId) != -1 && sTask5) {
short sNextId = sGetId(sId);
// Print markers used for distancing
//debug_printf("markers: %d %d\r\n", xValueRead.class_id, xDistanceValue[sNextId].class_id);
// Compute the distance to the fiducial
double dD = sApproxSqrt(sPow(sPosX-(short) (xDistanceValue[sNextId].position_x*100.0f),2) +
sPow(sPosY-(short) (xDistanceValue[sNextId].position_y*100.0f),2));
dD = (33379*sPow((short) dD,2) - 2288800*dD + 44475000)/10000;
//debug_printf(">> Distance: %d\r\n", (short) dD);
// Calculate the XYZ coordinates.
double dDegX = sDegreesX - servoMIN_DEGREES - (servoMIN_DEGREES+servoMAX_DEGREES)/2;
double dDegY = sDegreesY - servoMIN_DEGREES;
sX = (short) (dD*(sin((double) (dDegX/180.0f*3.14f))));
sY = (short) (dD*(sin((double) (dDegY/180.0f*3.14f))));
sZ = (short) (dD*(cos((double) (dDegX/180.0f*3.14f))));
//debug_printf(">> Angles: %d %d\r\n", (short) dDegX, (short) dDegY);
//debug_printf(">> Point: %d %d %d\r\n", sX, sY, sZ);
// On detecting the blimp, set the goal to 1.5m in X and flight plan to 2
if (sId < 3 && sFlightPlanStage == servotaskFLIGHT_PLAN_1) {
sGoalPoint = sX + 1500;
sGoalCounter = 0;
sFlightPlanStage = servotaskFLIGHT_PLAN_2;
debug_printf("Starting stage 2\t\t\ Goal: %d\r\n", sGoalPoint);
// If in stage 2, check if it has reached it's goal point. if this is confirmed
// using a counter, move to stage 3
} else if (sFlightPlanStage == servotaskFLIGHT_PLAN_2) {
sSetSpeed(0xFF);
if (sX > sGoalPoint) {
sGoalCounter++;
}
if (sGoalCounter > 10) {
sFlightPlanStage = servotaskFLIGHT_PLAN_3;
debug_printf("Starting stage 3\r\n");
}
// Set the goal point 1.5m back in x and move to stage 4
} else if (sFlightPlanStage == servotaskFLIGHT_PLAN_3) {
sRequestTurnLeft();
if (sId > 2) {
sGoalPoint = sX - 1500;
sGoalCounter = 0;
sFlightPlanStage = servotaskFLIGHT_PLAN_4;
debug_printf("Starting stage 4\t\t\ Goal: %d\r\n", sGoalPoint);
}
/**
Extract the discover information and boot server entry from the
cached packets if unspecified.
@param[in] Private Pointer to PxeBc private data.
@param[in] Type The type of bootstrap to perform.
@param[in, out] DiscoverInfo Pointer to EFI_PXE_BASE_CODE_DISCOVER_INFO.
@param[out] BootEntry Pointer to PXEBC_BOOT_SVR_ENTRY.
@param[out] SrvList Pointer to EFI_PXE_BASE_CODE_SRVLIST.
@retval EFI_SUCCESS Successfully extracted the information.
@retval EFI_DEVICE_ERROR Failed to extract the information.
**/
EFI_STATUS
PxeBcExtractDiscoverInfo (
IN PXEBC_PRIVATE_DATA *Private,
IN UINT16 Type,
IN OUT EFI_PXE_BASE_CODE_DISCOVER_INFO **DiscoverInfo,
OUT PXEBC_BOOT_SVR_ENTRY **BootEntry,
OUT EFI_PXE_BASE_CODE_SRVLIST **SrvList
)
{
EFI_PXE_BASE_CODE_MODE *Mode;
PXEBC_DHCP4_PACKET_CACHE *Cache4;
PXEBC_VENDOR_OPTION *VendorOpt;
PXEBC_BOOT_SVR_ENTRY *Entry;
BOOLEAN IsFound;
EFI_PXE_BASE_CODE_DISCOVER_INFO *Info;
UINT16 Index;
Mode = Private->PxeBc.Mode;
Info = *DiscoverInfo;
if (Mode->UsingIpv6) {
Info->IpCnt = 1;
Info->UseUCast = TRUE;
Info->SrvList[0].Type = Type;
Info->SrvList[0].AcceptAnyResponse = FALSE;
//
// There is no vendor options specified in DHCPv6, so take BootFileUrl in the last cached packet.
//
CopyMem (&Info->SrvList[0].IpAddr, &Private->ServerIp, sizeof (EFI_IP_ADDRESS));
*SrvList = Info->SrvList;
} else {
Entry = NULL;
IsFound = FALSE;
Cache4 = (Mode->ProxyOfferReceived) ? &Private->ProxyOffer.Dhcp4 : &Private->DhcpAck.Dhcp4;
VendorOpt = &Cache4->VendorOpt;
if (!Mode->DhcpAckReceived || !IS_VALID_DISCOVER_VENDOR_OPTION (VendorOpt->BitMap)) {
//
// Address is not acquired or no discovery options.
//
return EFI_INVALID_PARAMETER;
}
//
// Parse the boot server entry from the vendor option in the last cached packet.
//
Info->UseMCast = (BOOLEAN) !IS_DISABLE_MCAST_DISCOVER (VendorOpt->DiscoverCtrl);
Info->UseBCast = (BOOLEAN) !IS_DISABLE_BCAST_DISCOVER (VendorOpt->DiscoverCtrl);
Info->MustUseList = (BOOLEAN) IS_ENABLE_USE_SERVER_LIST (VendorOpt->DiscoverCtrl);
Info->UseUCast = (BOOLEAN) IS_VALID_BOOT_SERVERS (VendorOpt->BitMap);
if (Info->UseMCast) {
//
// Get the multicast discover ip address from vendor option if has.
//
CopyMem (&Info->ServerMCastIp.v4, &VendorOpt->DiscoverMcastIp, sizeof (EFI_IPv4_ADDRESS));
}
Info->IpCnt = 0;
if (Info->UseUCast) {
Entry = VendorOpt->BootSvr;
while (((UINT8) (Entry - VendorOpt->BootSvr)) < VendorOpt->BootSvrLen) {
if (Entry->Type == HTONS (Type)) {
IsFound = TRUE;
break;
}
Entry = GET_NEXT_BOOT_SVR_ENTRY (Entry);
}
if (!IsFound) {
return EFI_DEVICE_ERROR;
}
Info->IpCnt = Entry->IpCnt;
if (Info->IpCnt >= 1) {
*DiscoverInfo = AllocatePool (sizeof (*Info) + (Info->IpCnt - 1) * sizeof (**SrvList));
if (*DiscoverInfo == NULL) {
return EFI_OUT_OF_RESOURCES;
}
CopyMem (*DiscoverInfo, Info, sizeof (*Info));
Info = *DiscoverInfo;
}
for (Index = 0; Index < Info->IpCnt; Index++) {
CopyMem (&Info->SrvList[Index].IpAddr, &Entry->IpAddr[Index], sizeof (EFI_IPv4_ADDRESS));
Info->SrvList[Index].AcceptAnyResponse = !Info->MustUseList;
Info->SrvList[Index].Type = NTOHS (Entry->Type);
}
}
*BootEntry = Entry;
*SrvList = Info->SrvList;
}
return EFI_SUCCESS;
}
// obs³u¿ pakiet
void udp_config_handle_packet(unsigned char* data, unsigned int len) {
// otrzymany pakiet
udp_config_packet *packet = (udp_config_packet*) data;
// ignoruj niepoprawne pakiety
if (packet->start != UDP_CONFIG_MAGIC) {
return;
}
// ignoruj pakiety z ustawionym adresem MAC innego urz¹dzenia
if (memcmp(packet->mac, nic_get_mac(), 6) != 0) {
// MAC niezgodny, sprawdŸ czy nie ustawiono adresu broadcast MAC (ff:ff:ff:ff:ff:ff)
for (i=0; i<6; i++) {
if (packet->mac[i] != 0xFF) {
return;
}
}
}
switch(packet->type) {
// wyszukiwanie urz¹dzeñ
case UDP_CONFIG_TYPE_DISCOVERY:
// wyszukiwanie okreœlonego typu urz¹dzeñ
if ( (packet->length == 1) && (packet->data[0] != UDP_CONFIG_DEVICE_TYPE) ) {
// szukany inny typ urz¹dzenia
return;
}
// formuj pakiet
packet->type = UDP_CONFIG_TYPE_MY_CONFIG;
len = udp_config_fill(packet->data);
break;
// identyfikacja wybranego urz¹dzenia
case UDP_CONFIG_TYPE_IDENTIFY:
// mrugaj naprzemiennie diodami RX/TX przez 3 sekundy
udp_identify_timer = 30;
packet->type = UDP_CONFIG_TYPE_IDENTIFY_OK;
len = 0;
break;
// niepoprawny typ
default:
return;
}
// odeœlij pakiet
struct uip_udp_conn* conn;
conn = uip_udp_new(&uip_udp_conn->ripaddr, uip_udp_conn->rport);
if (!conn) {
return;
}
// wyœlij z portu, na którym pakiet zosta³ odebrany
uip_udp_bind(conn, HTONS(UDP_CONFIG_PORT));
// nag³ówek
packet->start = UDP_CONFIG_MAGIC;
packet->length = len;
// nadawca
memcpy(packet->mac, nic_get_mac(), 6);
// wyœlij
uip_udp_send(len + 10);
// czekaj na wys³anie
nic_wait_for_send();
// zamknij po³¹czenia UDP (przychodz¹cy broadcast i wychodz¹cy unicast)
uip_udp_remove(conn);
uip_udp_remove(uip_udp_conn);
}
/** Initialization function for the simple TELNET webserver. */
void TELNETServerApp_Init(void)
{
/* Listen on port 23 for TELNET connections from hosts */
uip_listen(HTONS(TELNET_SERVER_PORT));
}
/*
* The initialization function. We must explicitly call this function
* from the system initialization code, some time after uip_init() is
* called.
*/
void socket_app_init(void) {
/* We start to listen for connections on TCP port 1000. */
uip_listen(HTONS(1000));
}
void ecmd_net_init()
{
/* Without teensy support we use tcp */
uip_listen(HTONS(ECMD_TCP_PORT), ecmd_net_main);
}
void
yport_net_init(void)
{
uip_listen(HTONS(YPORT_PORT), yport_net_main);
}
static int dhcpc_sendmsg(struct dhcpc_state_s *pdhcpc,
struct dhcpc_state *presult, int msgtype)
{
struct sockaddr_in addr;
uint8_t *pend;
in_addr_t serverid = INADDR_BROADCAST;
int len;
/* Create the common message header settings */
memset(&pdhcpc->packet, 0, sizeof(struct dhcp_msg));
pdhcpc->packet.op = DHCP_REQUEST;
pdhcpc->packet.htype = DHCP_HTYPE_ETHERNET;
pdhcpc->packet.hlen = pdhcpc->ds_maclen;
memcpy(pdhcpc->packet.xid, xid, 4);
memcpy(pdhcpc->packet.chaddr, pdhcpc->ds_macaddr, pdhcpc->ds_maclen);
memset(&pdhcpc->packet.chaddr[pdhcpc->ds_maclen], 0, 16 - pdhcpc->ds_maclen);
memcpy(pdhcpc->packet.options, magic_cookie, sizeof(magic_cookie));
/* Add the common header options */
pend = &pdhcpc->packet.options[4];
pend = dhcpc_addmsgtype(pend, msgtype);
/* Handle the message specific settings */
switch (msgtype)
{
/* Broadcast DISCOVER message to all servers */
case DHCPDISCOVER:
pdhcpc->packet.flags = HTONS(BOOTP_BROADCAST); /* Broadcast bit. */
pend = dhcpc_addreqoptions(pend);
break;
/* Send REQUEST message to the server that sent the *first* OFFER */
case DHCPREQUEST:
pdhcpc->packet.flags = HTONS(BOOTP_BROADCAST); /* Broadcast bit. */
memcpy(pdhcpc->packet.ciaddr, &pdhcpc->ipaddr.s_addr, 4);
pend = dhcpc_addserverid(&pdhcpc->serverid, pend);
pend = dhcpc_addreqipaddr(&pdhcpc->ipaddr, pend);
break;
/* Send DECLINE message to the server that sent the *last* OFFER */
case DHCPDECLINE:
memcpy(pdhcpc->packet.ciaddr, &presult->ipaddr.s_addr, 4);
pend = dhcpc_addserverid(&presult->serverid, pend);
serverid = presult->serverid.s_addr;
break;
default:
return ERROR;
}
pend = dhcpc_addend(pend);
len = pend - (uint8_t*)&pdhcpc->packet;
/* Send the request */
addr.sin_family = AF_INET;
addr.sin_port = HTONS(DHCPC_SERVER_PORT);
addr.sin_addr.s_addr = serverid;
return sendto(pdhcpc->sockfd, &pdhcpc->packet, len, 0,
(struct sockaddr*)&addr, sizeof(struct sockaddr_in));
}
static void e1000_receive(struct e1000_dev *e1000)
{
int head = e1000->rx_ring.head;
unsigned char *cp = (unsigned char *)
(e1000->rx_ring.buf + head * CONFIG_E1000_BUFF_SIZE);
int cnt;
while (e1000->rx_ring.desc[head].desc_status)
{
/* Check for errors and update statistics */
/* Here we do not handle packets that exceed packet-buffer size */
if ((e1000->rx_ring.desc[head].desc_status & 3) == 1)
{
cprintf("NIC READ: Oversized packet\n");
goto next;
}
/* Check if the packet is a valid size for the uIP buffer configuration */
/* get the number of actual data-bytes in this packet */
cnt = e1000->rx_ring.desc[head].packet_length;
if (cnt > CONFIG_NET_BUFSIZE || cnt < 14)
{
cprintf("NIC READ: invalid package size\n");
goto next;
}
/* Copy the data data from the hardware to e1000->uip_dev.d_buf. Set
* amount of data in e1000->uip_dev.d_len
*/
/* now we try to copy these data-bytes to the UIP buffer */
memcpy(e1000->uip_dev.d_buf, cp, cnt);
e1000->uip_dev.d_len = cnt;
/* We only accept IP packets of the configured type and ARP packets */
#ifdef CONFIG_NET_IPv6
if (BUF->type == HTONS(UIP_ETHTYPE_IP6))
#else
{
if (BUF->type == HTONS(UIP_ETHTYPE_IP))
#endif
{
arp_ipin(&e1000->uip_dev);
uip_input(&e1000->uip_dev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (e1000->uip_dev.d_len > 0)
{
arp_out(&e1000->uip_dev);
e1000_transmit(e1000);
}
}
else if (BUF->type == htons(UIP_ETHTYPE_ARP))
{
arp_arpin(&e1000->uip_dev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (e1000->uip_dev.d_len > 0)
{
e1000_transmit(e1000);
}
}
}
next:
e1000->rx_ring.desc[head].desc_status = 0;
e1000->rx_ring.head = (head + 1) % CONFIG_E1000_N_RX_DESC;
e1000->rx_ring.free++;
head = e1000->rx_ring.head;
cp = (unsigned char *)(e1000->rx_ring.buf + head * CONFIG_E1000_BUFF_SIZE);
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
//Init system and pheripherals
Platform_Config();
printf("System init complete!\n");
//Init NetDev
ENC28J60_Init(hostMac);
printf("NetDev init complete!\n");
//Init packet buffer of NIC
arp_hdr = (struct net_arp_hdr *) malloc (sizeof(struct net_arp_hdr));
icmp_hdr = (struct net_icmpip_hdr *) malloc (sizeof(struct net_icmpip_hdr));
memset(pktBuffer, 0, sizeof(pktBuffer));
for(int i=0; i<200; i++)
{
pktBuffer[i] = i;
}
//Init heart beat LED
TIM1_PWM_Config(1000000);
TIM1_PWM_SetDuty(1, 0);
TIM1_PWM_SetDuty(2, 0);
TIM15_General_Config(1000);
printf("=== ARP & ICMP Test Program ===\n By Nights 2015-01-31\n");
while(1)
{
//Check Link
{
isLinkedNow = ENC28J60_GetLinkStatus();
if(isLinkedBefore == ENC_LINK_DOWN && isLinkedNow == ENC_LINK_UP)
printf("NetDev: link up!\n");
else if(isLinkedBefore == ENC_LINK_UP && isLinkedNow == ENC_LINK_DOWN)
printf("NetDev: link down!\n");
isLinkedBefore = isLinkedNow;
}
//ARP & ICMP responding.
if(isLinkedNow == ENC_LINK_UP)
{
pktLen = ENC28J60_PacketReceive(pktBuffer, sizeof(pktBuffer));
if(pktLen)
{
// // Dump the pkt.
// printf("NetDev: received data:");
// for(int i=0; i<pktLen; i++)
// {
// printf(" %02X", pktBuffer[i]);
// }
// printf("\n---\n");
// Check if it's an ARP pkt.
memcpy(arp_hdr, pktBuffer, sizeof(struct net_arp_hdr));
//arp_hdr = (struct net_arp_hdr *) &pktBuffer[0];
if(arp_hdr->ethhdr.type == HTONS(UIP_ETHTYPE_ARP) && arp_hdr->opcode == HTONS(ARP_REQUEST))
{
printf("NetDev: received ARP request from %d.%d.%d.%d\n",
(arp_hdr->sipaddr[0] & 0xFF), (arp_hdr->sipaddr[0] >> 8), (arp_hdr->sipaddr[1] & 0xFF), (arp_hdr->sipaddr[0] >> 8));
/* The reply opcode is 2. */
arp_hdr->opcode = HTONS(2);
memcpy(arp_hdr->dhwaddr.addr, arp_hdr->shwaddr.addr, 6);
memcpy(arp_hdr->shwaddr.addr, hostMac, 6);
memcpy(arp_hdr->ethhdr.src.addr, hostMac, 6);
memcpy(arp_hdr->ethhdr.dest.addr, arp_hdr->dhwaddr.addr, 6);
arp_hdr->dipaddr[0] = arp_hdr->sipaddr[0];
arp_hdr->dipaddr[1] = arp_hdr->sipaddr[1];
arp_hdr->sipaddr[0] = HTONS(hostIpaddr[0]);
arp_hdr->sipaddr[1] = HTONS(hostIpaddr[1]);
arp_hdr->opcode = HTONS(ARP_REPLY);
memcpy(pktBuffer, arp_hdr, sizeof(struct net_arp_hdr));
printf("NetDev: sending ARP reply...");
ENC28J60_PacketSend(pktBuffer, sizeof(struct net_arp_hdr));
printf("done!\n");
}
// Check if it's an ICMP pkt.
else if(arp_hdr->ethhdr.type == HTONS(UIP_ETHTYPE_IP))
{
memcpy(icmp_hdr, pktBuffer, sizeof(struct net_icmpip_hdr));
if(icmp_hdr->proto == UIP_PROTO_ICMP && icmp_hdr->type == ICMP_ECHO)
{
printf("NetDev: received ICMP request from %d.%d.%d.%d\n",
(icmp_hdr->srcipaddr[0] & 0xFF), (icmp_hdr->srcipaddr[0] >> 8), (icmp_hdr->srcipaddr[1] & 0xFF), (icmp_hdr->srcipaddr[0] >> 8));
// Dill with MAC part
memcpy(icmp_hdr->ethhdr.dest.addr, icmp_hdr->ethhdr.src.addr, 6);
memcpy(icmp_hdr->ethhdr.src.addr, hostMac, 6);
// Dill with IP&ICMP part
memcpy(icmp_hdr->destipaddr, icmp_hdr->srcipaddr, sizeof(icmp_hdr->srcipaddr));
icmp_hdr->srcipaddr[0] = HTONS(hostIpaddr[0]);
icmp_hdr->srcipaddr[1] = HTONS(hostIpaddr[1]);
icmp_hdr->type = ICMP_ECHO_REPLY;
if(icmp_hdr->icmpchksum >= HTONS(0xffff - (ICMP_ECHO << 8)))
{
icmp_hdr->icmpchksum += HTONS(ICMP_ECHO << 8) + 1;
}
else
{
icmp_hdr->icmpchksum += HTONS(ICMP_ECHO << 8);
}
memcpy(pktBuffer, icmp_hdr, sizeof(struct net_icmpip_hdr));
printf("NetDev: sending ICMP reply...");
ENC28J60_PacketSend(pktBuffer, sizeof(struct net_icmpip_hdr) + UIP_LLH_LEN);
printf("done!\n");
}
NTSTATUS
DispatchRequest (
IN PPRIMARY_SESSION PrimarySession
)
{
NTSTATUS status;
IN PNDFS_REQUEST_HEADER ndfsRequestHeader;
ASSERT( NTOHS(PrimarySession->Thread.NdfsRequestHeader.Mid2) < PrimarySession->SessionContext.SessionSlotCount );
ASSERT( PrimarySession->Thread.SessionSlot[NTOHS(PrimarySession->Thread.NdfsRequestHeader.Mid2)].State == SLOT_WAIT );
ASSERT( PrimarySession->Thread.ReceiveOverlapped.Request[0].IoStatusBlock.Information == sizeof(NDFS_REQUEST_HEADER) );
RtlCopyMemory( PrimarySession->Thread.SessionSlot[NTOHS(PrimarySession->Thread.NdfsRequestHeader.Mid2)].RequestMessageBuffer,
&PrimarySession->Thread.NdfsRequestHeader,
sizeof(NDFS_REQUEST_HEADER) );
ndfsRequestHeader = (PNDFS_REQUEST_HEADER)PrimarySession->Thread.SessionSlot[NTOHS(PrimarySession->Thread.NdfsRequestHeader.Mid2)].RequestMessageBuffer;
DebugTrace2( 0, Dbg,
("DispatchRequest: ndfsRequestHeader->Command = %d\n",
ndfsRequestHeader->Command) );
switch (ndfsRequestHeader->Command) {
case NDFS_COMMAND_LOGOFF: {
PNDFS_REQUEST_LOGOFF ndfsRequestLogoff;
PNDFS_REPLY_HEADER ndfsReplyHeader;
PNDFS_REPLY_LOGOFF ndfsReplyLogoff;
if (PrimarySession->Thread.SessionState != SESSION_TREE_CONNECT) {
ASSERT(NDASFAT_BUG);
status = STATUS_UNSUCCESSFUL;
break;
}
if (!(NTOHS(ndfsRequestHeader->Uid2) == PrimarySession->SessionContext.Uid &&
NTOHS(ndfsRequestHeader->Tid2) == PrimarySession->SessionContext.Tid)) {
ASSERT(NDASFAT_BUG);
status = STATUS_UNSUCCESSFUL;
break;
}
ASSERT( NTOHL(ndfsRequestHeader->MessageSize4) == sizeof(NDFS_REQUEST_HEADER) + sizeof(NDFS_REQUEST_LOGOFF) );
ndfsRequestLogoff = (PNDFS_REQUEST_LOGOFF)(ndfsRequestHeader+1);
status = RecvMessage( PrimarySession->ConnectionFileObject,
&PrimarySession->RecvNdasFcStatistics,
NULL,
(UINT8 *)ndfsRequestLogoff,
sizeof(NDFS_REQUEST_LOGOFF) );
if (status != STATUS_SUCCESS) {
ASSERT(NDASFAT_BUG);
break;
}
ndfsReplyHeader = (PNDFS_REPLY_HEADER)(ndfsRequestLogoff+1);
RtlCopyMemory( ndfsReplyHeader->Protocol, NDFS_PROTOCOL, sizeof(ndfsReplyHeader->Protocol) );
ndfsReplyHeader->Status = NDFS_SUCCESS;
ndfsReplyHeader->Flags = 0;
ndfsReplyHeader->Uid2 = HTONS(PrimarySession->SessionContext.Uid);
ndfsReplyHeader->Tid2 = 0;
ndfsReplyHeader->Mid2 = 0;
ndfsReplyHeader->MessageSize4 = HTONL((UINT32)(sizeof(NDFS_REPLY_HEADER)+sizeof(NDFS_REPLY_LOGOFF)));
ndfsReplyLogoff = (PNDFS_REPLY_LOGOFF)(ndfsReplyHeader+1);
if (NTOHL(ndfsRequestLogoff->SessionKey4) != PrimarySession->SessionContext.SessionKey) {
ndfsReplyLogoff->Status = NDFS_LOGOFF_UNSUCCESSFUL;
} else {
ndfsReplyLogoff->Status = NDFS_LOGOFF_SUCCESS;
}
status = SendMessage( PrimarySession->ConnectionFileObject,
&PrimarySession->SendNdasFcStatistics,
NULL,
(UINT8 *)ndfsReplyHeader,
NTOHL(ndfsReplyHeader->MessageSize4) );
if (status != STATUS_SUCCESS) {
break;
}
PrimarySession->Thread.SessionState = SESSION_CLOSED;
status = STATUS_SUCCESS;
break;
}
case NDFS_COMMAND_EXECUTE: {
UINT16 mid;
if(PrimarySession->SessionContext.NdfsMinorVersion == NDFS_PROTOCOL_MINOR_0) {
if (PrimarySession->Thread.SessionState != SESSION_TREE_CONNECT) {
ASSERT( NDASFAT_BUG );
status = STATUS_UNSUCCESSFUL;
break;
}
}
if (!(NTOHS(ndfsRequestHeader->Uid2) == PrimarySession->SessionContext.Uid &&
NTOHS(ndfsRequestHeader->Tid2) == PrimarySession->SessionContext.Tid)) {
ASSERT( NDASFAT_BUG );
status = STATUS_UNSUCCESSFUL;
break;
}
mid = NTOHS(ndfsRequestHeader->Mid2);
PrimarySession->Thread.SessionSlot[mid].RequestMessageBufferLength = sizeof(NDFS_REQUEST_HEADER) + sizeof(NDFS_WINXP_REQUEST_HEADER) + DEFAULT_NDAS_MAX_DATA_SIZE;
RtlZeroMemory( &PrimarySession->Thread.SessionSlot[mid].RequestMessageBuffer[sizeof(NDFS_REQUEST_HEADER)],
PrimarySession->Thread.SessionSlot[mid].RequestMessageBufferLength - sizeof(NDFS_REQUEST_HEADER) );
PrimarySession->Thread.SessionSlot[mid].ReplyMessageBufferLength = sizeof(NDFS_REPLY_HEADER) + sizeof(NDFS_WINXP_REPLY_HEADER) + DEFAULT_NDAS_MAX_DATA_SIZE;
RtlZeroMemory( PrimarySession->Thread.SessionSlot[mid].ReplyMessageBuffer,
PrimarySession->Thread.SessionSlot[mid].ReplyMessageBufferLength );
ASSERT( NTOHL(ndfsRequestHeader->MessageSize4) >= sizeof(NDFS_REQUEST_HEADER) + sizeof(NDFS_WINXP_REQUEST_HEADER) );
status = ReceiveNdfsWinxpMessage( PrimarySession, mid );
if (status != STATUS_SUCCESS)
break;
if (PrimarySession->Thread.SessionSlot[mid].State != SLOT_WAIT) {
break;
}
PrimarySession->Thread.SessionSlot[mid].State = SLOT_EXECUTING;
PrimarySession->Thread.IdleSlotCount --;
if (PrimarySession->SessionContext.SessionSlotCount == 1) {
ASSERT( mid == 0 );
DispatchWinXpRequestWorker( PrimarySession, mid );
PrimarySession->Thread.SessionSlot[mid].State = SLOT_WAIT;
PrimarySession->Thread.IdleSlotCount ++;
if (PrimarySession->Thread.SessionSlot[mid].Status == STATUS_SUCCESS) {
PNDFS_REPLY_HEADER ndfsReplyHeader;
ndfsReplyHeader = (PNDFS_REPLY_HEADER)PrimarySession->Thread.SessionSlot[mid].ReplyMessageBuffer;
PrimarySession->Thread.SessionSlot[mid].Status =
SendNdfsWinxpMessage( PrimarySession,
ndfsReplyHeader,
PrimarySession->Thread.SessionSlot[mid].NdfsWinxpReplyHeader,
PrimarySession->Thread.SessionSlot[mid].ReplyDataSize,
mid );
}
if (PrimarySession->Thread.SessionSlot[mid].ExtendWinxpRequestMessagePool) {
ExFreePool( PrimarySession->Thread.SessionSlot[mid].ExtendWinxpRequestMessagePool );
PrimarySession->Thread.SessionSlot[mid].ExtendWinxpRequestMessagePool = NULL;
PrimarySession->Thread.SessionSlot[mid].ExtendWinxpReplyMessagePoolLength = 0;
}
if (PrimarySession->Thread.SessionSlot[mid].ExtendWinxpReplyMessagePool) {
ExFreePool( PrimarySession->Thread.SessionSlot[mid].ExtendWinxpReplyMessagePool );
PrimarySession->Thread.SessionSlot[mid].ExtendWinxpReplyMessagePool = NULL;
PrimarySession->Thread.SessionSlot[mid].ExtendWinxpReplyMessagePoolLength = 0;
}
NDAS_ASSERT( PrimarySession->Thread.SessionSlot[mid].Status != STATUS_PENDING );
if (PrimarySession->Thread.SessionSlot[mid].Status != STATUS_SUCCESS) {
SetFlag( PrimarySession->Thread.Flags, PRIMARY_SESSION_THREAD_FLAG_ERROR );
status = PrimarySession->Thread.SessionSlot[mid].Status;
break;
}
status = STATUS_SUCCESS;
break;
}
if (mid == 0)
ExInitializeWorkItem( &PrimarySession->Thread.SessionSlot[mid].WorkQueueItem,
DispatchWinXpRequestWorker0,
PrimarySession );
if (mid == 1)
ExInitializeWorkItem( &PrimarySession->Thread.SessionSlot[mid].WorkQueueItem,
DispatchWinXpRequestWorker1,
PrimarySession );
if (mid == 2)
ExInitializeWorkItem( &PrimarySession->Thread.SessionSlot[mid].WorkQueueItem,
DispatchWinXpRequestWorker2,
PrimarySession );
if (mid == 3)
ExInitializeWorkItem( &PrimarySession->Thread.SessionSlot[mid].WorkQueueItem,
DispatchWinXpRequestWorker3,
PrimarySession );
ExQueueWorkItem( &PrimarySession->Thread.SessionSlot[mid].WorkQueueItem, DelayedWorkQueue );
status = STATUS_PENDING;
break;
}
default:
NDAS_ASSERT( FALSE );
status = STATUS_UNSUCCESSFUL;
break;
}
return status;
}
/*-----------------------------------------------------------------------------------*/
void
uip_arp_out(void)
{
struct arp_entry *tabptr;
/* Find the destination IP address in the ARP table and construct
the Ethernet header. If the destination IP addres isn't on the
local network, we use the default router's IP address instead.
If not ARP table entry is found, we overwrite the original IP
packet with an ARP request for the IP address. */
/* First check if destination is a local broadcast. */
if(uip_ipaddr_cmp(IPBUF->destipaddr, broadcast_ipaddr)) {
memcpy(IPBUF->ethhdr.dest.addr, broadcast_ethaddr.addr, 6);
} else {
/* Check if the destination address is on the local network. */
if(!uip_ipaddr_maskcmp(IPBUF->destipaddr, uip_hostaddr, uip_netmask)) {
/* Destination address was not on the local network, so we need to
use the default router's IP address instead of the destination
address when determining the MAC address. */
uip_ipaddr_copy(ipaddr, uip_draddr);
} else {
/* Else, we use the destination IP address. */
uip_ipaddr_copy(ipaddr, IPBUF->destipaddr);
}
for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
tabptr = &arp_table[i];
if(uip_ipaddr_cmp(ipaddr, tabptr->ipaddr)) {
break;
}
}
if(i == UIP_ARPTAB_SIZE) {
/* The destination address was not in our ARP table, so we
overwrite the IP packet with an ARP request. */
#if 0
memset(BUF->ethhdr.dest.addr, 0xff, 6);
memset(BUF->dhwaddr.addr, 0x00, 6);
memcpy(BUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
memcpy(BUF->shwaddr.addr, uip_ethaddr.addr, 6);
uip_ipaddr_copy(BUF->dipaddr, ipaddr);
uip_ipaddr_copy(BUF->sipaddr, uip_hostaddr);
BUF->opcode = HTONS(ARP_REQUEST); /* ARP request. */
BUF->hwtype = HTONS(ARP_HWTYPE_ETH);
BUF->protocol = HTONS(UIP_ETHTYPE_IP);
BUF->hwlen = 6;
BUF->protolen = 4;
BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP);
#else
uip_create_broadcast_eth_arp_pkt(BUF, ipaddr,
ARP_REQUEST);
#endif
uip_appdata = &uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN];
uip_len = sizeof(struct arp_hdr);
return;
}
/* Build an ethernet header. */
memcpy(IPBUF->ethhdr.dest.addr, tabptr->ethaddr.addr, 6);
}
memcpy(IPBUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
IPBUF->ethhdr.type = HTONS(UIP_ETHTYPE_IP);
uip_len += sizeof(struct uip_eth_hdr);
}
int
gre_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
struct rtentry *rt)
{
int error = 0;
struct gre_softc *sc = (struct gre_softc *) (ifp->if_softc);
struct greip *gh = NULL;
struct ip *inp = NULL;
u_int8_t ip_tos = 0;
u_int16_t etype = 0;
struct mobile_h mob_h;
struct m_tag *mtag;
if ((ifp->if_flags & IFF_UP) == 0 ||
sc->g_src.s_addr == INADDR_ANY || sc->g_dst.s_addr == INADDR_ANY) {
m_freem(m);
error = ENETDOWN;
goto end;
}
#ifdef DIAGNOSTIC
if (ifp->if_rdomain != rtable_l2(m->m_pkthdr.ph_rtableid)) {
printf("%s: trying to send packet on wrong domain. "
"if %d vs. mbuf %d, AF %d\n", ifp->if_xname,
ifp->if_rdomain, rtable_l2(m->m_pkthdr.ph_rtableid),
dst->sa_family);
}
#endif
/* Try to limit infinite recursion through misconfiguration. */
for (mtag = m_tag_find(m, PACKET_TAG_GRE, NULL); mtag;
mtag = m_tag_find(m, PACKET_TAG_GRE, mtag)) {
if (!bcmp((caddr_t)(mtag + 1), &ifp, sizeof(struct ifnet *))) {
IF_DROP(&ifp->if_snd);
m_freem(m);
error = EIO;
goto end;
}
}
mtag = m_tag_get(PACKET_TAG_GRE, sizeof(struct ifnet *), M_NOWAIT);
if (mtag == NULL) {
IF_DROP(&ifp->if_snd);
m_freem(m);
error = ENOBUFS;
goto end;
}
bcopy(&ifp, (caddr_t)(mtag + 1), sizeof(struct ifnet *));
m_tag_prepend(m, mtag);
m->m_flags &= ~(M_BCAST|M_MCAST);
#if NBPFILTER > 0
if (ifp->if_bpf)
bpf_mtap_af(ifp->if_bpf, dst->sa_family, m, BPF_DIRECTION_OUT);
#endif
if (sc->g_proto == IPPROTO_MOBILE) {
if (ip_mobile_allow == 0) {
IF_DROP(&ifp->if_snd);
m_freem(m);
error = EACCES;
goto end;
}
if (dst->sa_family == AF_INET) {
struct mbuf *m0;
int msiz;
/*
* Make sure the complete IP header (with options)
* is in the first mbuf.
*/
if (m->m_len < sizeof(struct ip)) {
m = m_pullup(m, sizeof(struct ip));
if (m == NULL) {
IF_DROP(&ifp->if_snd);
error = ENOBUFS;
goto end;
} else
inp = mtod(m, struct ip *);
if (m->m_len < inp->ip_hl << 2) {
m = m_pullup(m, inp->ip_hl << 2);
if (m == NULL) {
IF_DROP(&ifp->if_snd);
error = ENOBUFS;
goto end;
}
}
}
inp = mtod(m, struct ip *);
bzero(&mob_h, MOB_H_SIZ_L);
mob_h.proto = (inp->ip_p) << 8;
mob_h.odst = inp->ip_dst.s_addr;
inp->ip_dst.s_addr = sc->g_dst.s_addr;
/*
* If the packet comes from our host, we only change
* the destination address in the IP header.
* Otherwise we need to save and change the source.
*/
if (inp->ip_src.s_addr == sc->g_src.s_addr) {
msiz = MOB_H_SIZ_S;
} else {
mob_h.proto |= MOB_H_SBIT;
mob_h.osrc = inp->ip_src.s_addr;
inp->ip_src.s_addr = sc->g_src.s_addr;
msiz = MOB_H_SIZ_L;
}
HTONS(mob_h.proto);
mob_h.hcrc = gre_in_cksum((u_int16_t *) &mob_h, msiz);
/* Squeeze in the mobility header */
if ((m->m_data - msiz) < m->m_pktdat) {
/* Need new mbuf */
MGETHDR(m0, M_DONTWAIT, MT_HEADER);
if (m0 == NULL) {
IF_DROP(&ifp->if_snd);
m_freem(m);
error = ENOBUFS;
goto end;
}
M_MOVE_HDR(m0, m);
m0->m_len = msiz + (inp->ip_hl << 2);
m0->m_data += max_linkhdr;
m0->m_pkthdr.len = m->m_pkthdr.len + msiz;
m->m_data += inp->ip_hl << 2;
m->m_len -= inp->ip_hl << 2;
bcopy((caddr_t) inp, mtod(m0, caddr_t),
sizeof(struct ip));
m0->m_next = m;
m = m0;
} else { /* we have some space left in the old one */
m->m_data -= msiz;
m->m_len += msiz;
m->m_pkthdr.len += msiz;
bcopy(inp, mtod(m, caddr_t),
inp->ip_hl << 2);
}
/* Copy Mobility header */
inp = mtod(m, struct ip *);
bcopy(&mob_h, (caddr_t)(inp + 1), (unsigned) msiz);
inp->ip_len = htons(ntohs(inp->ip_len) + msiz);
} else { /* AF_INET */
void rtos_vnet_recv(struct rgmp_vnet *rgmp_vnet, char *data, int len)
{
struct vnet_driver_s *vnet = rgmp_vnet->priv;
do
{
/* Check if the packet is a valid size for the network buffer
* configuration.
*/
if (len > CONFIG_NET_ETH_MTU || len < 14)
{
#ifdef CONFIG_DEBUG
cprintf("VNET: receive invalid packet of size %d\n", len);
#endif
return;
}
/* Copy the data data from the hardware to vnet->sk_dev.d_buf. Set
* amount of data in vnet->sk_dev.d_len
*/
memcpy(vnet->sk_dev.d_buf, data, len);
vnet->sk_dev.d_len = len;
#ifdef CONFIG_NET_PKT
/* When packet sockets are enabled, feed the frame into the packet tap */
pkt_input(&vnet->sk_dev);
#endif
/* We only accept IP packets of the configured type and ARP packets */
#ifdef CONFIG_NET_IPv4
if (BUF->type == HTONS(ETHTYPE_IP))
{
nllvdbg("IPv4 frame\n");
/* Handle ARP on input then give the IPv4 packet to the network
* layer
*/
arp_ipin(&vnet->sk_dev);
ipv4_input(&vnet->sk_dev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (vnet->sk_dev.d_len > 0)
{
/* Update the Ethernet header with the correct MAC address */
#ifdef CONFIG_NET_IPv6
if (IFF_IS_IPv4(vnet->sk_dev.d_flags))
#endif
{
arp_out(&vnet->sk_dev);
}
#ifdef CONFIG_NET_IPv6
else
{
neighbor_out(&vnet->sk_dev);
}
#endif
/* And send the packet */
vnet_transmit(vnet);
}
}
else
#endif
#ifdef CONFIG_NET_IPv6
if (BUF->type == HTONS(ETHTYPE_IP6))
{
nllvdbg("Iv6 frame\n");
/* Give the IPv6 packet to the network layer */
ipv6_input(&vnet->sk_dev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (vnet->sk_dev.d_len > 0)
{
/* Update the Ethernet header with the correct MAC address */
#ifdef CONFIG_NET_IPv4
if (IFF_IS_IPv4(vnet->sk_dev.d_flags))
{
arp_out(&vnet->sk_dev);
}
else
#endif
#ifdef CONFIG_NET_IPv6
{
neighbor_out(&vnet->sk_dev);
}
#endif
/* And send the packet */
vnet_transmit(vnet);
}
}
else
#endif
#ifdef CONFIG_NET_ARP
if (BUF->type == htons(ETHTYPE_ARP))
{
arp_arpin(&vnet->sk_dev);
/* If the above function invocation resulted in data that should
* be sent out on the network, the field d_len will set to a
* value > 0.
*/
if (vnet->sk_dev.d_len > 0)
{
vnet_transmit(vnet);
}
}
#endif
}
while (0); /* While there are more packets to be processed */
}
error_t dnsSendQuery(DnsCacheEntry *entry)
{
error_t error;
size_t length;
size_t offset;
ChunkedBuffer *buffer;
DnsHeader *message;
DnsQuestion *dnsQuestion;
IpAddr destIpAddr;
#if (IPV4_SUPPORT == ENABLED)
//An IPv4 address is expected?
if(entry->type == HOST_TYPE_IPV4)
{
//Select the relevant DNS server
destIpAddr.length = sizeof(Ipv4Addr);
ipv4GetDnsServer(entry->interface, entry->dnsServerNum, &destIpAddr.ipv4Addr);
//Make sure the IP address is valid
if(destIpAddr.ipv4Addr == IPV4_UNSPECIFIED_ADDR)
return ERROR_NO_DNS_SERVER;
}
else
#endif
#if (IPV6_SUPPORT == ENABLED)
//An IPv6 address is expected?
if(entry->type == HOST_TYPE_IPV6)
{
//Select the relevant DNS server
destIpAddr.length = sizeof(Ipv6Addr);
ipv6GetDnsServer(entry->interface, entry->dnsServerNum, &destIpAddr.ipv6Addr);
//Make sure the IP address is valid
if(ipv6CompAddr(&destIpAddr.ipv6Addr, &IPV6_UNSPECIFIED_ADDR))
return ERROR_NO_DNS_SERVER;
}
else
#endif
//Invalid host type?
{
//Report an error
return ERROR_INVALID_PARAMETER;
}
//Allocate a memory buffer to hold the DNS query message
buffer = udpAllocBuffer(DNS_MESSAGE_MAX_SIZE, &offset);
//Failed to allocate buffer?
if(!buffer) return ERROR_OUT_OF_MEMORY;
//Point to the DNS header
message = chunkedBufferAt(buffer, offset);
//Format DNS query message
message->id = htons(entry->id);
message->qr = 0;
message->opcode = DNS_OPCODE_QUERY;
message->aa = 0;
message->tc = 0;
message->rd = 1;
message->ra = 0;
message->z = 0;
message->rcode = DNS_RCODE_NO_ERROR;
//The DNS query contains one question
message->qdcount = HTONS(1);
message->ancount = 0;
message->nscount = 0;
message->arcount = 0;
//Length of the DNS query message
length = sizeof(DnsHeader);
//Encode the host name using the DNS name notation
length += dnsEncodeName(entry->name, message->questions);
//Point to the corresponding question structure
dnsQuestion = DNS_GET_QUESTION(message, length);
#if (IPV4_SUPPORT == ENABLED)
//An IPv4 address is expected?
if(entry->type == HOST_TYPE_IPV4)
{
//Fill in question structure
dnsQuestion->qtype = HTONS(DNS_RR_TYPE_A);
dnsQuestion->qclass = HTONS(DNS_RR_CLASS_IN);
}
#endif
#if (IPV6_SUPPORT == ENABLED)
//An IPv6 address is expected?
if(entry->type == HOST_TYPE_IPV6)
{
//Fill in question structure
dnsQuestion->qtype = HTONS(DNS_RR_TYPE_AAAA);
dnsQuestion->qclass = HTONS(DNS_RR_CLASS_IN);
}
#endif
//Update the length of the DNS query message
length += sizeof(DnsQuestion);
//Adjust the length of the multi-part buffer
chunkedBufferSetLength(buffer, offset + length);
//Debug message
TRACE_INFO("Sending DNS message (%" PRIuSIZE " bytes)...\r\n", length);
//Dump message
dnsDumpMessage(message, length);
//Send DNS query message
error = udpSendDatagramEx(entry->interface, entry->port,
&destIpAddr, DNS_PORT, buffer, offset, 0);
//Free previously allocated memory
chunkedBufferFree(buffer);
//Return status code
return error;
}
/**
Build the options buffer for the DHCPv6 request packet.
@param[in] Private The pointer to HTTP BOOT driver private data.
@param[out] OptList The pointer to the option pointer array.
@param[in] Buffer The pointer to the buffer to contain the option list.
@return Index The count of the built-in options.
**/
UINT32
HttpBootBuildDhcp6Options (
IN HTTP_BOOT_PRIVATE_DATA *Private,
OUT EFI_DHCP6_PACKET_OPTION **OptList,
IN UINT8 *Buffer
)
{
HTTP_BOOT_DHCP6_OPTION_ENTRY OptEnt;
UINT16 Value;
UINT32 Index;
Index = 0;
OptList[0] = (EFI_DHCP6_PACKET_OPTION *) Buffer;
//
// Append client option request option
//
OptList[Index]->OpCode = HTONS (HTTP_BOOT_DHCP6_OPT_ORO);
OptList[Index]->OpLen = HTONS (8);
OptEnt.Oro = (HTTP_BOOT_DHCP6_OPTION_ORO *) OptList[Index]->Data;
OptEnt.Oro->OpCode[0] = HTONS(HTTP_BOOT_DHCP6_OPT_BOOT_FILE_URL);
OptEnt.Oro->OpCode[1] = HTONS(HTTP_BOOT_DHCP6_OPT_BOOT_FILE_PARAM);
OptEnt.Oro->OpCode[2] = HTONS(HTTP_BOOT_DHCP6_OPT_DNS_SERVERS);
OptEnt.Oro->OpCode[3] = HTONS(HTTP_BOOT_DHCP6_OPT_VENDOR_CLASS);
Index++;
OptList[Index] = GET_NEXT_DHCP6_OPTION (OptList[Index - 1]);
//
// Append client network device interface option
//
OptList[Index]->OpCode = HTONS (HTTP_BOOT_DHCP6_OPT_UNDI);
OptList[Index]->OpLen = HTONS ((UINT16)3);
OptEnt.Undi = (HTTP_BOOT_DHCP6_OPTION_UNDI *) OptList[Index]->Data;
if (Private->Nii != NULL) {
OptEnt.Undi->Type = Private->Nii->Type;
OptEnt.Undi->MajorVer = Private->Nii->MajorVer;
OptEnt.Undi->MinorVer = Private->Nii->MinorVer;
} else {
OptEnt.Undi->Type = DEFAULT_UNDI_TYPE;
OptEnt.Undi->MajorVer = DEFAULT_UNDI_MAJOR;
OptEnt.Undi->MinorVer = DEFAULT_UNDI_MINOR;
}
Index++;
OptList[Index] = GET_NEXT_DHCP6_OPTION (OptList[Index - 1]);
//
// Append client system architecture option
//
OptList[Index]->OpCode = HTONS (HTTP_BOOT_DHCP6_OPT_ARCH);
OptList[Index]->OpLen = HTONS ((UINT16) sizeof (HTTP_BOOT_DHCP6_OPTION_ARCH));
OptEnt.Arch = (HTTP_BOOT_DHCP6_OPTION_ARCH *) OptList[Index]->Data;
Value = HTONS (EFI_HTTP_BOOT_CLIENT_SYSTEM_ARCHITECTURE);
CopyMem (&OptEnt.Arch->Type, &Value, sizeof (UINT16));
Index++;
OptList[Index] = GET_NEXT_DHCP6_OPTION (OptList[Index - 1]);
//
// Append vendor class identify option.
//
OptList[Index]->OpCode = HTONS (HTTP_BOOT_DHCP6_OPT_VENDOR_CLASS);
OptList[Index]->OpLen = HTONS ((UINT16) sizeof (HTTP_BOOT_DHCP6_OPTION_VENDOR_CLASS));
OptEnt.VendorClass = (HTTP_BOOT_DHCP6_OPTION_VENDOR_CLASS *) OptList[Index]->Data;
OptEnt.VendorClass->Vendor = HTONL (HTTP_BOOT_DHCP6_ENTERPRISE_NUM);
OptEnt.VendorClass->ClassLen = HTONS ((UINT16) sizeof (HTTP_BOOT_CLASS_ID));
CopyMem (
&OptEnt.VendorClass->ClassId,
DEFAULT_CLASS_ID_DATA,
sizeof (HTTP_BOOT_CLASS_ID)
);
HttpBootUintnToAscDecWithFormat (
EFI_HTTP_BOOT_CLIENT_SYSTEM_ARCHITECTURE,
OptEnt.VendorClass->ClassId.ArchitectureType,
sizeof (OptEnt.VendorClass->ClassId.ArchitectureType)
);
if (Private->Nii != NULL) {
CopyMem (
OptEnt.VendorClass->ClassId.InterfaceName,
Private->Nii->StringId,
sizeof (OptEnt.VendorClass->ClassId.InterfaceName)
);
HttpBootUintnToAscDecWithFormat (
Private->Nii->MajorVer,
OptEnt.VendorClass->ClassId.UndiMajor,
sizeof (OptEnt.VendorClass->ClassId.UndiMajor)
);
HttpBootUintnToAscDecWithFormat (
Private->Nii->MinorVer,
OptEnt.VendorClass->ClassId.UndiMinor,
sizeof (OptEnt.VendorClass->ClassId.UndiMinor)
);
}
Index++;
return Index;
}
/*------------------------------------------------------------------------------*/
u8_t
uip_fw_forward(void)
{
struct fwcache_entry *fw;
/* First check if the packet is destined for ourselves and return 0
to indicate that the packet should be processed locally. */
if(BUF->destipaddr[0] == uip_hostaddr[0] &&
BUF->destipaddr[1] == uip_hostaddr[1]) {
return UIP_FW_LOCAL;
}
/* If we use ping IP address configuration, and our IP address is
not yet configured, we should intercept all ICMP echo packets. */
#if UIP_PINGADDRCONF
if((uip_hostaddr[0] | uip_hostaddr[1]) == 0 &&
BUF->proto == UIP_PROTO_ICMP &&
ICMPBUF->type == ICMP_ECHO) {
return UIP_FW_LOCAL;
}
#endif /* UIP_PINGADDRCONF */
/* Check if the packet is in the forwarding cache already, and if so
we drop it. */
for(fw = fwcache; fw < &fwcache[FWCACHE_SIZE]; ++fw) {
if(fw->timer != 0 &&
#if UIP_REASSEMBLY > 0
fw->len == BUF->len &&
fw->offset == BUF->ipoffset &&
#endif
fw->ipid == BUF->ipid &&
fw->srcipaddr[0] == BUF->srcipaddr[0] &&
fw->srcipaddr[1] == BUF->srcipaddr[1] &&
fw->destipaddr[0] == BUF->destipaddr[0] &&
fw->destipaddr[1] == BUF->destipaddr[1] &&
#if notdef
fw->payload[0] == BUF->srcport &&
fw->payload[1] == BUF->destport &&
#endif
fw->proto == BUF->proto) {
/* Drop packet. */
return UIP_FW_FORWARDED;
}
}
/* If the TTL reaches zero we produce an ICMP time exceeded message
in the uip_buf buffer and forward that packet back to the sender
of the packet. */
if(BUF->ttl <= 1) {
/* No time exceeded for broadcasts and multicasts! */
if(BUF->destipaddr[0] == 0xffff && BUF->destipaddr[1] == 0xffff) {
return UIP_FW_LOCAL;
}
time_exceeded();
}
/* Decrement the TTL (time-to-live) value in the IP header */
BUF->ttl = BUF->ttl - 1;
/* Update the IP checksum. */
if(BUF->ipchksum >= HTONS(0xffff - 0x0100)) {
BUF->ipchksum = BUF->ipchksum + HTONS(0x0100) + 1;
} else {
BUF->ipchksum = BUF->ipchksum + HTONS(0x0100);
}
if(uip_len > 0) {
uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_TCPIP_HLEN];
uip_fw_output();
}
#if UIP_BROADCAST
if(BUF->destipaddr[0] == 0xffff && BUF->destipaddr[1] == 0xffff) {
return UIP_FW_LOCAL;
}
#endif /* UIP_BROADCAST */
/* Return non-zero to indicate that the packet was forwarded and that no
other processing should be made. */
return UIP_FW_FORWARDED;
}
void uip_icmpinput(struct uip_driver_s *dev)
{
struct uip_icmpip_hdr *picmp = ICMPBUF;
#ifdef CONFIG_NET_STATISTICS
uip_stat.icmp.recv++;
#endif
#ifndef CONFIG_NET_IPv6
/* ICMPv4 processing code follows. */
/* ICMP echo (i.e., ping) processing. This is simple, we only change the
* ICMP type from ECHO to ECHO_REPLY and adjust the ICMP checksum before
* we return the packet.
*/
if (picmp->type == ICMP_ECHO_REQUEST)
{
/* If we are configured to use ping IP address assignment, we use
* the destination IP address of this ping packet and assign it to
* ourself.
*/
#ifdef CONFIG_NET_PINGADDRCONF
if (dev->d_ipaddr == 0)
{
dev->d_ipaddr = picmp->destipaddr;
}
#endif
/* Change the ICMP type */
picmp->type = ICMP_ECHO_REPLY;
/* Swap IP addresses. */
uiphdr_ipaddr_copy(picmp->destipaddr, picmp->srcipaddr);
uiphdr_ipaddr_copy(picmp->srcipaddr, &dev->d_ipaddr);
/* Recalculate the ICMP checksum */
#if 0
/* The slow way... sum over the ICMP message */
picmp->icmpchksum = 0;
picmp->icmpchksum = ~uip_icmpchksum(dev, (((uint16_t)picmp->len[0] << 8) | (uint16_t)picmp->len[1]) - UIP_IPH_LEN);
if (picmp->icmpchksum == 0)
{
picmp->icmpchksum = 0xffff;
}
#else
/* The quick way -- Since only the type has changed, just adjust the
* checksum for the change of type
*/
if (picmp->icmpchksum >= HTONS(0xffff - (ICMP_ECHO_REQUEST << 8)))
{
picmp->icmpchksum += HTONS(ICMP_ECHO_REQUEST << 8) + 1;
}
else
{
picmp->icmpchksum += HTONS(ICMP_ECHO_REQUEST << 8);
}
#endif
nllvdbg("Outgoing ICMP packet length: %d (%d)\n",
dev->d_len, (picmp->len[0] << 8) | picmp->len[1]);
#ifdef CONFIG_NET_STATISTICS
uip_stat.icmp.sent++;
uip_stat.ip.sent++;
#endif
}
/* If an ICMP echo reply is received then there should also be
* a thread waiting to received the echo response.
*/
#ifdef CONFIG_NET_ICMP_PING
else if (picmp->type == ICMP_ECHO_REPLY && g_echocallback)
{
(void)uip_callbackexecute(dev, picmp, UIP_ECHOREPLY, g_echocallback);
}
#endif
/* Otherwise the ICMP input was not processed */
else
{
nlldbg("Unknown ICMP cmd: %d\n", picmp->type);
goto typeerr;
}
return;
typeerr:
#ifdef CONFIG_NET_STATISTICS
uip_stat.icmp.typeerr++;
uip_stat.icmp.drop++;
#endif
dev->d_len = 0;
#else /* !CONFIG_NET_IPv6 */
/* If we get a neighbor solicitation for our address we should send
* a neighbor advertisement message back.
*/
if (picmp->type == ICMP6_NEIGHBOR_SOLICITATION)
{
if (uip_ipaddr_cmp(picmp->icmp6data, dev->d_ipaddr))
{
if (picmp->options[0] == ICMP6_OPTION_SOURCE_LINK_ADDRESS)
{
/* Save the sender's address in our neighbor list. */
uiphdr_neighbor_add(picmp->srcipaddr, &(picmp->options[2]));
}
/* We should now send a neighbor advertisement back to where the
* neighbor solicitation came from.
*/
picmp->type = ICMP6_NEIGHBOR_ADVERTISEMENT;
picmp->flags = ICMP6_FLAG_S; /* Solicited flag. */
picmp->reserved1 = picmp->reserved2 = picmp->reserved3 = 0;
uiphdr_ipaddr_copy(picmp->destipaddr, picmp->srcipaddr);
uiphdr_ipaddr_copy(picmp->srcipaddr, &dev->d_ipaddr);
picmp->options[0] = ICMP6_OPTION_TARGET_LINK_ADDRESS;
picmp->options[1] = 1; /* Options length, 1 = 8 bytes. */
memcpy(&(picmp->options[2]), &dev->d_mac, IFHWADDRLEN);
picmp->icmpchksum = 0;
picmp->icmpchksum = ~uip_icmp6chksum(dev);
}
else
{
goto drop;
}
}
else if (picmp->type == ICMP6_ECHO_REQUEST)
{
/* ICMP echo (i.e., ping) processing. This is simple, we only
* change the ICMP type from ECHO to ECHO_REPLY and update the
* ICMP checksum before we return the packet.
*/
picmp->type = ICMP6_ECHO_REPLY;
uiphdr_ipaddr_copy(picmp->destipaddr, picmp->srcipaddr);
uiphdr_ipaddr_copy(picmp->srcipaddr, &dev->d_ipaddr);
picmp->icmpchksum = 0;
picmp->icmpchksum = ~uip_icmp6chksum(dev);
}
/* If an ICMP echo reply is received then there should also be
* a thread waiting to received the echo response.
*/
#ifdef CONFIG_NET_ICMP_PING
else if (picmp->type == ICMP6_ECHO_REPLY && g_echocallback)
{
uint16_t flags = UIP_ECHOREPLY;
if (g_echocallback)
{
/* Dispatch the ECHO reply to the waiting thread */
flags = uip_callbackexecute(dev, picmp, flags, g_echocallback);
}
/* If the ECHO reply was not handled, then drop the packet */
if (flags == UIP_ECHOREPLY)
{
/* The ECHO reply was not handled */
goto drop;
}
}
#endif
else
{
nlldbg("Unknown ICMP6 cmd: %d\n", picmp->type);
goto typeerr;
}
nllvdbg("Outgoing ICMP6 packet length: %d (%d)\n",
dev->d_len, (picmp->len[0] << 8) | picmp->len[1]);
#ifdef CONFIG_NET_STATISTICS
uip_stat.icmp.sent++;
uip_stat.ip.sent++;
#endif
return;
typeerr:
#ifdef CONFIG_NET_STATISTICS
uip_stat.icmp.typeerr++;
#endif
drop:
#ifdef CONFIG_NET_STATISTICS
uip_stat.icmp.drop++;
#endif
dev->d_len = 0;
#endif /* !CONFIG_NET_IPv6 */
}
int thttpd_main(int argc, char **argv)
{
int num_ready;
int cnum;
FAR struct connect_s *conn;
FAR httpd_conn *hc;
httpd_sockaddr sa;
struct timeval tv;
#ifdef CONFIG_THTTPD_DIR
int ret;
#endif
nvdbg("THTTPD started\n");
/* Setup host address */
#ifdef CONFIG_NET_IPv6
# error "IPv6 support not yet implemented"
#else
sa.sin_family = AF_INET;
sa.sin_port = HTONS(CONFIG_THTTPD_PORT);
sa.sin_addr.s_addr = HTONL(CONFIG_THTTPD_IPADDR);
#endif
/* Initialize the fdwatch package to handle all of the configured
* socket descriptors
*/
fw = fdwatch_initialize(CONFIG_NSOCKET_DESCRIPTORS);
if (!fw)
{
ndbg("fdwatch initialization failure\n");
exit(1);
}
/* Switch directories again if requested */
#ifdef CONFIG_THTTPD_DATADIR
if (chdir(CONFIG_THTTPD_DATADIR) < 0)
{
ndbg("chdir to %s: %d\n", CONFIG_THTTPD_DATADIR, errno);
exit(1);
}
#endif
/* Initialize the timer package */
tmr_init();
/* Initialize the HTTP layer */
nvdbg("Calling httpd_initialize()\n");
hs = httpd_initialize(&sa);
if (!hs)
{
ndbg("httpd_initialize() failed\n");
exit(1);
}
/* Set up the occasional timer */
if (tmr_create(NULL, occasional, JunkClientData, CONFIG_THTTPD_OCCASIONAL_MSEC * 1000L, 1) == NULL)
{
ndbg("tmr_create(occasional) failed\n");
exit(1);
}
/* Set up the idle timer */
if (tmr_create(NULL, idle, JunkClientData, 5 * 1000L, 1) == NULL)
{
ndbg("tmr_create(idle) failed\n");
exit(1);
}
/* Initialize our connections table */
connects = NEW(struct connect_s, AVAILABLE_FDS);
if (connects == NULL)
{
ndbg("Out of memory allocating a struct connect_s\n");
exit(1);
}
for (cnum = 0; cnum < AVAILABLE_FDS; ++cnum)
{
connects[cnum].conn_state = CNST_FREE;
connects[cnum].next = &connects[cnum + 1];
connects[cnum].hc = NULL;
}
connects[AVAILABLE_FDS-1].next = NULL; /* End of link list */
free_connections = connects; /* Beginning of the link list */
if (hs != NULL)
{
if (hs->listen_fd != -1)
{
fdwatch_add_fd(fw, hs->listen_fd, NULL);
}
}
/* Main loop */
nvdbg("Entering the main loop\n");
(void)gettimeofday(&tv, NULL);
for (;;)
{
/* Do the fd watch */
num_ready = fdwatch(fw, tmr_mstimeout(&tv));
if (num_ready < 0)
{
if (errno == EINTR || errno == EAGAIN)
{
/* Not errors... try again */
continue;
}
ndbg("fdwatch failed: %d\n", errno);
exit(1);
}
(void)gettimeofday(&tv, NULL);
if (num_ready == 0)
{
/* No fd's are ready - run the timers */
tmr_run(&tv);
continue;
}
/* Is it a new connection? */
if (fdwatch_check_fd(fw, hs->listen_fd))
{
if (!handle_newconnect(&tv, hs->listen_fd))
{
/* Go around the loop and do another fdwatch, rather than
* dropping through and processing existing connections. New
* connections always get priority.
*/
continue;
}
}
/* Find the connections that need servicing */
while ((conn = (struct connect_s*)fdwatch_get_next_client_data(fw)) != (struct connect_s*)-1)
{
if (conn)
{
hc = conn->hc;
if (fdwatch_check_fd(fw, hc->conn_fd))
{
nvdbg("Handle conn_state %d\n", conn->conn_state);
switch (conn->conn_state)
{
case CNST_READING:
{
handle_read(conn, &tv);
/* If a GET request was received and a file is ready to
* be sent, then fall through to send the file.
*/
if (conn->conn_state != CNST_SENDING)
{
break;
}
}
case CNST_SENDING:
{
/* Send a file -- this really should be performed on a
* separate thread to keep the serve from locking up during
* the write.
*/
handle_send(conn, &tv);
}
break;
case CNST_LINGERING:
{
/* Linger close the connection */
handle_linger(conn, &tv);
}
break;
}
}
}
}
tmr_run(&tv);
}
/* The main loop terminated */
shut_down();
ndbg("Exiting\n");
exit(0);
}
uip_ipaddr_copy(&rreq_addr, host);
command = COMMAND_SEND_RREQ;
process_post(&uaodv_process, PROCESS_EVENT_MSG, NULL);
timer_set(&next_time, CLOCK_SECOND/8); /* Max 10/s per RFC3561. */
return NULL;
}
PROCESS_THREAD(uaodv_process, ev, data)
{
PROCESS_EXITHANDLER(goto exit);
PROCESS_BEGIN();
printf("uaodv_process starting %lu\n", (unsigned long) my_hseqno);
bcastconn = udp_broadcast_new(HTONS(UAODV_UDPPORT), NULL);
unicastconn = udp_broadcast_new(HTONS(UAODV_UDPPORT), NULL);
while(1) {
PROCESS_WAIT_EVENT();
if(ev == tcpip_event) {
if(uip_newdata()) {
handle_incoming_packet();
continue;
}
if(uip_poll()) {
if(command == COMMAND_SEND_RREQ) {
if(uaodv_rt_lookup(&rreq_addr) == NULL)
send_rreq(&rreq_addr);
} else if (command == COMMAND_SEND_RERR) {
/*-----------------------------------------------------------------------------------*/
void
uip_arp_out(void)
{
struct arp_entry *tabptr = 0;
/* Find the destination IP address in the ARP table and construct
the Ethernet header. If the destination IP addres isn't on the
local network, we use the default router's IP address instead.
If not ARP table entry is found, we overwrite the original IP
packet with an ARP request for the IP address. */
/* Check if the destination address is on the local network. */
if((IPBUF->destipaddr[0] & uip_arp_netmask[0]) !=
(uip_hostaddr[0] & uip_arp_netmask[0]) ||
(IPBUF->destipaddr[1] & uip_arp_netmask[1]) !=
(uip_hostaddr[1] & uip_arp_netmask[1])) {
/* Destination address was not on the local network, so we need to
use the default router's IP address instead of the destination
address when determining the MAC address. */
ipaddr[0] = uip_arp_draddr[0];
ipaddr[1] = uip_arp_draddr[1];
} else {
/* Else, we use the destination IP address. */
ipaddr[0] = IPBUF->destipaddr[0];
ipaddr[1] = IPBUF->destipaddr[1];
}
for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
tabptr = &arp_table[i];
if(ipaddr[0] == tabptr->ipaddr[0] &&
ipaddr[1] == tabptr->ipaddr[1])
break;
}
if(i == UIP_ARPTAB_SIZE) {
/* The destination address was not in our ARP table, so we
overwrite the IP packet with an ARP request. */
memset(BUF->ethhdr.dest.addr, 0xff, 6);
memset(BUF->dhwaddr.addr, 0x00, 6);
memcpy(BUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
memcpy(BUF->shwaddr.addr, uip_ethaddr.addr, 6);
BUF->dipaddr[0] = ipaddr[0];
BUF->dipaddr[1] = ipaddr[1];
BUF->sipaddr[0] = uip_hostaddr[0];
BUF->sipaddr[1] = uip_hostaddr[1];
BUF->opcode = HTONS(ARP_REQUEST); /* ARP request. */
BUF->hwtype = HTONS(ARP_HWTYPE_ETH);
BUF->protocol = HTONS(UIP_ETHTYPE_IP);
BUF->hwlen = 6;
BUF->protolen = 4;
BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP);
uip_appdata = &uip_buf[40 + UIP_LLH_LEN];
uip_len = sizeof(struct arp_hdr);
return;
}
/* Build an ethernet header. */
memcpy(IPBUF->ethhdr.dest.addr, tabptr->ethaddr.addr, 6);
memcpy(IPBUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
IPBUF->ethhdr.type = HTONS(UIP_ETHTYPE_IP);
uip_len += sizeof(struct uip_eth_hdr);
}
/**
* \brief Initialize the web server
*
* This function initializes the web server and should be
* called at system boot-up.
*/
void
httpd_init(void)
{
uip_listen(HTONS(80));
}
NTSTATUS
LspNoOperation(
IN PLANSCSI_SESSION LSS,
IN UINT32 TargetId,
OUT PBYTE PduResponse
)
{
_int8 PduBuffer[MAX_REQUEST_SIZE];
PLANSCSI_H2R_PDU_HEADER pRequestHeader;
LANSCSI_PDU_POINTERS pdu;
NTSTATUS ntStatus;
//
// Check Parameters.
//
if(PduResponse == NULL) {
KDPrintM(DBG_PROTO_ERROR, ("pResult is NULL!!!\n"));
return STATUS_INVALID_PARAMETER;
}
//
// Make Request.
//
memset(PduBuffer, 0, MAX_REQUEST_SIZE);
pRequestHeader = (PLANSCSI_H2R_PDU_HEADER)PduBuffer;
pRequestHeader->Opcode = NOP_H2R;
pRequestHeader->HPID = HTONL(LSS->HPID);
pRequestHeader->RPID = HTONS(LSS->RPID);
pRequestHeader->PathCommandTag = HTONL(++LSS->CommandTag);
pRequestHeader->TargetID = TargetId;
//
// Send Request.
//
pdu.pH2RHeader = (PLANSCSI_H2R_PDU_HEADER)pRequestHeader;
ntStatus = LspSendRequest(LSS, &pdu, NULL);
if(!NT_SUCCESS(ntStatus)) {
KDPrintM(DBG_PROTO_ERROR, ("Error when Send Request.\n"));
return ntStatus;
}
if (LSS->HWVersion == LANSCSIIDE_VERSION_2_5) {
// NDAS 2.5 replies to NOP
// Read Reply.
ntStatus = LspReadReply(LSS, (PCHAR)PduBuffer, &pdu, NULL);
if(!NT_SUCCESS(ntStatus)) {
KDPrintM(DBG_PROTO_ERROR, ("Error when read request.\n"));
return ntStatus;
}
if (NOP_R2H != pdu.pR2HHeader->Opcode) {
KDPrintM(DBG_PROTO_ERROR, ("Invalid opcode %x replied to NOP.\n", pdu.pR2HHeader->Opcode));
return ntStatus;
}
} else {
}
*PduResponse = LANSCSI_RESPONSE_SUCCESS;
return STATUS_SUCCESS;
}
/* -------------------------------------------------------------------------- */
void xtcpd_unlisten(int linknum, int port_number){
unregister_listener(tcp_listeners, linknum, port_number, NUM_TCP_LISTENERS);
uip_unlisten(HTONS(port_number));
}
// http server init
void httpd_init(void){
fs_init();
uip_listen(HTONS(80));
}
/* -----------------------------------------------------------------------------
* xtcpd_appcall
*
* this function is called, when a package comes in for an upper layer
* application.
* -------------------------------------------------------------------------- */
void
xtcpd_appcall(void)
{
xtcpd_state_t *s;
/* --------------- DHCP (v4) --------------- */
if (uip_udpconnection() &&
(uip_udp_conn->lport == HTONS(DHCPC_CLIENT_PORT) ||
uip_udp_conn->lport == HTONS(DHCPC_SERVER_PORT))) {
#if UIP_USE_DHCP
dhcpc_appcall();
#endif
return;
}
/* --------- set up a new connection ---------- */
if (uip_udpconnection()){
s = (xtcpd_state_t *) &(uip_udp_conn->appstate);
if (uip_newdata()) {
// Set remote port to upper layer state
s->conn.remote_port = HTONS(UDPBUF->srcport);
uip_ipaddr_copy(s->conn.remote_addr.u8, BUF->srcipaddr.u8);
}
} else if (uip_conn == NULL) {
// dodgy uip_conn
return;
} else {
s = (xtcpd_state_t *) &(uip_conn->appstate);
}
/* ------ passing new connection event up to the upper xtcp layer ---- */
if (uip_connected()) {
if (!uip_udpconnection()) {
init_xtcpd_state(s,
XTCP_PROTOCOL_TCP,
*((xtcp_ipaddr_t *) (&uip_conn->ripaddr)),
uip_conn->lport,
uip_conn->rport,
uip_conn);
xtcpd_event(XTCP_NEW_CONNECTION, s);
} else {
init_xtcpd_state(s,
XTCP_PROTOCOL_UDP,
*((xtcp_ipaddr_t *) (&uip_udp_conn->ripaddr)),
uip_udp_conn->lport,
uip_udp_conn->rport,
uip_udp_conn);
xtcpd_event(XTCP_NEW_CONNECTION, s);
}
}
/* --------------- new data event to deliver --------------- */
if (uip_newdata() && uip_len > 0) {
if (s->linknum != -1) {
xtcpd_service_clients_until_ready(s->linknum, xtcp_cons.links, xtcp_cons.nr);
xtcpd_recv(xtcp_cons.links, s->linknum, xtcp_cons.nr,
s,
uip_appdata,
uip_datalen());
if (!uip_udpconnection() && s->s.ack_recv_mode) {
uip_stop();
}
}
} else if (uip_aborted()) {
xtcpd_event(XTCP_ABORTED, s);
return;
} else if (uip_timedout()) {
xtcpd_event(XTCP_TIMED_OUT, s);
return;
}
/* ------------ passing acknowleg event to upper layer ------------- */
if (uip_acked()) {
int len;
if (s->linknum != -1) {
len =
do_xtcpd_send(xtcp_cons.links[s->linknum],
XTCP_SENT_DATA,
s,
uip_appdata,
uip_udpconnection() ? XTCP_CLIENT_BUF_SIZE : uip_mss());
uip_send(uip_appdata, len);
}
}
/* -------------- retransmit the last package -------------- */
if (uip_rexmit()) {
int len;
if (s->linknum != -1) {
xtcpd_service_clients_until_ready(s->linknum, xtcp_cons.links, xtcp_cons.nr);
#ifdef XTCP_ENABLE_PARTIAL_PACKET_ACK
s->conn.outstanding = 0;
#endif
len = xtcpd_send(xtcp_cons.links[s->linknum],
XTCP_RESEND_DATA,
s,
uip_appdata,
uip_udpconnection() ? XTCP_CLIENT_BUF_SIZE : uip_mss());
if (len != 0)
uip_send(uip_appdata, len);
}
}
/* --------------- poll a connection --------------- */
if (uip_poll()) {
uip_xtcpd_handle_poll(s);
}
#if XTCP_ENABLE_PUSH_FLAG_NOTIFICATION
if (uip_tcp_push()) {
xtcpd_event(XTCP_PUSH_DATA, s);
}
#endif
/* ------------- connection close event ------------ */
if (uip_closed()) {
if (!s->s.closed){
s->s.closed = 1;
xtcpd_event(XTCP_CLOSED, s);
}
return;
}
}
//--------------------------------------------------------------------------//
void PktFinish(PRAWPKT Pkt)
//--------------------------------------------------------------------------//
{
*(USHORT*)(Pkt->Data + 4) = HTONS(Pkt->Len - 6);
}
//----------------------------------------------------------------------------
//Sendet DHCP messages an Broadcast
void dhcp_message (unsigned char type)
{
struct dhcp_msg *msg;
unsigned char *options;
for (unsigned int i=0; i < sizeof (struct dhcp_msg); i++) //clear eth_buffer to 0
{
eth_buffer[UDP_DATA_START+i] = 0;
}
msg = (struct dhcp_msg *)ð_buffer[UDP_DATA_START];
msg->op = 1; // BOOTREQUEST
msg->htype = 1; // Ethernet
msg->hlen = 6; // Ethernet MAC
msg->xid[0] = MYMAC6; //use the MAC as the ID to be unique in the LAN
msg->xid[1] = MYMAC5;
msg->xid[2] = MYMAC4;
msg->xid[3] = MYMAC3;
msg->flags = HTONS(0x8000);
msg->chaddr[0] = MYMAC1;
msg->chaddr[1] = MYMAC2;
msg->chaddr[2] = MYMAC3;
msg->chaddr[3] = MYMAC4;
msg->chaddr[4] = MYMAC5;
msg->chaddr[5] = MYMAC6;
options = &msg->options[0]; //options
*options++ = 99; //magic cookie
*options++ = 130;
*options++ = 83;
*options++ = 99;
*options++ = 53; // Option 53: DHCP message type DHCP Discover
*options++ = 1; // len = 1
*options++ = type; // 1 = DHCP Discover
*options++ = 55; // Option 55: parameter request list
*options++ = 3; // len = 3
*options++ = 1; // netmask
*options++ = 3; // router
*options++ = 6; // dns
*options++ = 50; // Option 54: requested IP
*options++ = 4; // len = 4
*options++ = dhcp_offer_ip[0];
*options++ = dhcp_offer_ip[1];
*options++ = dhcp_offer_ip[2];
*options++ = dhcp_offer_ip[3];
switch (type)
{
case DHCPDISCOVER:
dhcp_state = DHCP_STATE_DISCOVER_SENT;
DHCP_DEBUG("DISCOVER sent\r\n");
break;
case DHCPREQUEST:
*options++ = 54; // Option 54: server ID
*options++ = 4; // len = 4
*options++ = cache.serv_id[0];
*options++ = cache.serv_id[1];
*options++ = cache.serv_id[2];
*options++ = cache.serv_id[3];
dhcp_state = DHCP_STATE_REQUEST_SENT;
DHCP_DEBUG("REQUEST sent\r\n");
break;
default:
DHCP_DEBUG("Wrong DHCP msg type\r\n");
break;
}
*options++ = 12; // Option 12: host name
*options++ = 12; // len = 8
*options++ = 'A';
*options++ = 'V';
*options++ = 'R';
*options++ = '-';
*options++ = 'L';
*options++ = 'I';
*options++ = 'G';
*options++ = 'H';
*options++ = 'T';
*options++ = 'C';
*options++ = 'T';
*options++ = 'R';
*options = 0xff; //end option
create_new_udp_packet(sizeof (struct dhcp_msg),DHCP_CLIENT_PORT,DHCP_SERVER_PORT,(unsigned long)0xffffffff);
DHCP_DEBUG("\r\nmyip %1i.%1i.%1i.%1i\r\n", myip[0] , myip[1] , myip[2] , myip[3]);
DHCP_DEBUG("\r\nofferip %1i.%1i.%1i.%1i\r\n", dhcp_offer_ip[0] , dhcp_offer_ip[1] , dhcp_offer_ip[2] , dhcp_offer_ip[3]);
}