static boolean ROUTE_walk_test ( _ip_address node_ip, _ip_address node_mask, pointer node_data, pointer data ) { /* Body */ IP_ROUTE_PTR route = node_data; IP_IF_PTR ip_if_ptr; if (route != NULL) { if (route->DIRECT) { printf("DIRECT Route: %d.%d.%d.%d, NetIF=%x,DestIF=%x\n", IPBYTES(route->DIRECT->ADDRESS),route->DIRECT->NETIF->HANDLE, route->DIRECT->DESTIF->HANDLE ); } else if (route->VIRTUAL) { printf("VIRTUAL Route: %d.%d.%d.%d, IS DIRECT=%x,DestIF=%x\n", IPBYTES(route->VIRTUAL->ADDRESS), route->VIRTUAL->IS_DIRECT->HANDLE, route->VIRTUAL->DESTIF->HANDLE); } else if (route->INDIRECT) { printf("INDIRECT Route: %d.%d.%d.%d", IPBYTES(route->INDIRECT->GATEWAY) ); if (route->INDIRECT->IS_DIRECT) { ip_if_ptr = (IP_IF_PTR)route->INDIRECT->IS_DIRECT; printf(", IS DIRECT IF=%x\n", ip_if_ptr->HANDLE); } else { printf("\n"); } } /* Endif */ } return FALSE; } /* Endbody */
int_32 FTPc_open(FTPc_CONTEXT_PTR context_ptr, int_32 argc, char_ptr argv[] ) { int_32 response=0; if (argc != 2) { printf("Usage: open <host>\n"); } else if (context_ptr->HANDLE != NULL) { printf("Already connected to %s. Use close first.\n",context_ptr->HOSTNAME); } else { RTCS_resolve_ip_address( argv[1], &context_ptr->HOSTADDR, context_ptr->HOSTNAME, RTCS_SNAME_LEN ); if (!context_ptr->HOSTADDR) { printf("Unable to resolve host.\n"); } else { printf("Connecting to: %s [%ld.%ld.%ld.%ld]\n", context_ptr->HOSTNAME, IPBYTES(context_ptr->HOSTADDR)); response = FTP_open(&context_ptr->HANDLE,context_ptr->HOSTADDR,stdout); if (response == RTCS_ERROR) { printf("Unable to open %s\n",context_ptr->HOSTNAME); response = 0; context_ptr->HOSTADDR = 0; context_ptr->HANDLE = NULL; } } } return response; }
int_32 Shell_getroute(int_32 argc, char_ptr argv[] ) { /* Body */ boolean print_usage, shorthelp = FALSE; int_32 return_code = SHELL_EXIT_SUCCESS; _ip_address gate_ipaddr; _ip_address ipaddr; _ip_address ipmask; print_usage = Shell_check_help_request(argc, argv, &shorthelp ); if (!print_usage) { if (argc != 2) { return_code = SHELL_EXIT_ERROR; print_usage = TRUE; } else { if (! Shell_parse_ip_address( argv[1], &ipaddr )) { printf("Error, invalid ip address\n"); return_code = SHELL_EXIT_ERROR; } else if (argc > 2) { if (! Shell_parse_ip_address( argv[2], &ipmask )) { printf("Error, invalid ip mask\n"); return_code = SHELL_EXIT_ERROR; } } } if (return_code == SHELL_EXIT_SUCCESS) { gate_ipaddr = RTCS_get_route(ipaddr, ipmask); printf("The route to ip address: %d.%d.%d.%d, netmask: %d.%d.%d.%d is gateway %d.%d.%d.%d\n", IPBYTES(ipaddr),IPBYTES(ipmask),IPBYTES(gate_ipaddr)); } } if (print_usage) { if (shorthelp) { printf("%s <ipaddr> <netmask>\n", argv[0]); } else { printf("Usage: %s <ipaddr> <netmask>\n", argv[0]); printf(" <ipaddr> = IP address \n"); printf(" <netmask> = Network mask\n"); } } return return_code; } /* Endbody */
/*FUNCTION*------------------------------------------------ * * Function Name: PPP_start * Comments : * * *END*-----------------------------------------------------*/ void PPP_start(void) { uint_32 error; _rtcs_if_handle ihandle; MQX_FILE_PTR pfile; _iopcb_handle pio; _ppp_handle phandle; IPCP_DATA_STRUCT ipcp_data; _PPP_PAP_RSECRETS = rsecrets; /* Require authentication, allow PAP */ _PPP_PAP_LSECRET = &lsecret; /* Allow peer to request PAP */ _PPP_CHAP_LNAME = localname; /* Needed by CHAP */ _PPP_CHAP_RSECRETS = rsecrets; /* Require authentication, allow CHAP */ _PPP_CHAP_LSECRETS = lsecrets; /* Allow peer to request CHAP */ /* Install a route for a default gateway */ RTCS_gate_add(GATE_ADDR, INADDR_ANY, INADDR_ANY); pfile = fopen(PPP_DEVICE, NULL); #ifdef PPP_DEVICE_DUN _io_dun_install("dun:"); pfile = fopen("dun:", (char_ptr)pfile); #endif pio = _iopcb_ppphdlc_init(pfile); _PPP_ACCM = 0; error = PPP_initialize(pio, &phandle); if (error) { printf("\nPPP initialize: %lx", error); _task_block(); } /* Endif */ _iopcb_open(pio, PPP_lowerup, PPP_lowerdown, phandle); error = RTCS_if_add(phandle, RTCS_IF_PPP, &ihandle); if (error) { printf("\nIF add failed, error = %lx", error); _task_block(); } /* Endif */ _lwsem_create(&ppp_sem, 0); _mem_zero(&ipcp_data, sizeof(ipcp_data)); ipcp_data.IP_UP = PPP_linkup; ipcp_data.IP_DOWN = NULL; ipcp_data.IP_PARAM = &ppp_sem; ipcp_data.ACCEPT_LOCAL_ADDR = FALSE; ipcp_data.ACCEPT_REMOTE_ADDR = FALSE; ipcp_data.LOCAL_ADDR = PPP_LOCADDR; ipcp_data.REMOTE_ADDR = PPP_PEERADDR; ipcp_data.DEFAULT_NETMASK = TRUE; ipcp_data.DEFAULT_ROUTE = TRUE; error = RTCS_if_bind_IPCP(ihandle, &ipcp_data); if (error) { printf("\nIF bind failed, error = %lx", error); _task_block(); } /* Endif */ printf("\nPlease initiate PPP connection. Waiting..."); _lwsem_wait(&ppp_sem); printf("\nPPP device %s bound to %d.%d.%d.%d", PPP_DEVICE, IPBYTES(ipcp_data.LOCAL_ADDR)); }
int_32 Shell_Telnet_client(int_32 argc, char_ptr argv[] ) { /* Body */ _ip_address hostaddr; char hostname[MAX_HOSTNAMESIZE]; int_32 error; boolean print_usage, shorthelp = FALSE; int_32 return_code = SHELL_EXIT_SUCCESS; print_usage = Shell_check_help_request(argc, argv, &shorthelp ); if (!print_usage) { if (argc == 2) { RTCS_resolve_ip_address( argv[1], &hostaddr, hostname, MAX_HOSTNAMESIZE ); if (hostaddr) { printf("Connecting to %s [%ld.%ld.%ld.%ld]:\n", hostname, IPBYTES(hostaddr)); error = TELNET_connect(hostaddr); if (error) { printf("Connection failed, error 0x%04lX\n", error); return_code = SHELL_EXIT_ERROR; } printf("Connection closed\n", error); } else { printf("Unable to resolve host\n"); return_code = SHELL_EXIT_ERROR; } } else { printf("Error, %s invoked with incorrect number of arguments\n", argv[0]); print_usage = TRUE; } } if (print_usage) { if (shorthelp) { printf("%s <host>\n", argv[0]); } else { printf("Usage: %s <host>\n", argv[0]); printf(" <host> = host ip address or name\n"); } } return return_code; } /* Endbody */
int_32 Shell_get_host_by_name(int_32 argc, char_ptr argv[] ) { /* Body */ _ip_address hostaddr; char hostname[MAX_HOSTNAMESIZE]; boolean print_usage, shorthelp = FALSE; int_32 return_code = SHELL_EXIT_SUCCESS; print_usage = Shell_check_help_request(argc, argv, &shorthelp ); if (!print_usage) { if (argc == 2) { RTCS_resolve_ip_address( argv[1], &hostaddr, hostname, MAX_HOSTNAMESIZE ); if (hostaddr) { printf("%s...%ld.%ld.%ld.%ld\n", hostname, IPBYTES(hostaddr)); } else { #if RTCSCFG_ENABLE_DNS | RTCSCFG_ENABLE_LWDNS printf("Unable to resolve host\n"); #else printf("Unable to resolve host - dns service disabled\n"); #endif return_code = SHELL_EXIT_ERROR; } } else { printf("Error, %s invoked with incorrect number of arguments\n", argv[0]); return_code = SHELL_EXIT_ERROR; print_usage = TRUE; } } if (print_usage) { if (shorthelp) { printf("%s <host>\n", argv[0]); } else { printf("Usage: %s <host>\n", argv[0]); printf(" <host> = host ip address or name\n"); } } return return_code; } /* Endbody */
boolean init_network() { IPCFG_IP_ADDRESS_DATA ip_data; _enet_address enet_address; uint_32 error; _RTCS_socket_part_init = RTCS_NUMBER_OF_SOCKETS; _RTCS_socket_part_grow = 2; _RTCS_socket_part_max = 20; error = RTCS_create(); if (error != RTCS_OK) { printf("init_network: RTCS failed to initialize, error = %X", error); _task_block(); } _IP_forward = TRUE; ip_data.ip = ENET_IPADDR; ip_data.mask = ENET_IPMASK; // we dont need the gateway adress for the netgear-switch //ip_data.gateway = ENET_GATEWAY; // calculate the mac-adress ENET_get_mac_address (ENET_DEVICE, ENET_IPADDR, enet_address); // initialize the device error = ipcfg_init_device (ENET_DEVICE, enet_address); if (error != RTCS_OK) { printf("\nFailed to initialize ethernet device, error = %X", error); _task_block(); } #if RTCSCFG_ENABLE_LWDNS LWDNS_server_ipaddr = ENET_GATEWAY; ipcfg_add_dns_ip(ENET_DEVICE,LWDNS_server_ipaddr); #endif /* RTCSCFG_ENABLE_LWDNS */ printf("Setting static IP address ... "); error = ipcfg_bind_staticip (ENET_DEVICE, &ip_data); if (error != IPCFG_ERROR_OK) { printf("\nRTCS failed to bind interface with IPv4, error = %X", error); _task_block(); } else printf("OK\n"); ipcfg_get_ip(ENET_DEVICE, &ip_data); printf("IP Address : %d.%d.%d.%d\n",IPBYTES(ip_data.ip)); printf("Subnet Address : %d.%d.%d.%d\n",IPBYTES(ip_data.mask)); printf("Gateway Address : %d.%d.%d.%d\n",IPBYTES(ip_data.gateway)); printf("DNS Address : %d.%d.%d.%d\n",IPBYTES(ipcfg_get_dns_ip(ENET_DEVICE,0))); printf("MAC Address : %02x:%02x:%02x:%02x:%02x:%02x\n", enet_address[0], enet_address[1], enet_address[2], enet_address[3], enet_address[4], enet_address[5]); return TRUE; }
static int32_t Shell_ipconfig_status (uint32_t enet_device) { IPCFG_STATE state; bool link; bool task; _enet_address mac = {0}; IPCFG_IP_ADDRESS_DATA ip_data ; #if RTCSCFG_IPCFG_ENABLE_DNS _ip_address dns; #endif #if RTCSCFG_IPCFG_ENABLE_BOOT _ip_address tftp_serveraddress; unsigned char *tftp_servername; unsigned char *boot_filename; #endif #if RTCSCFG_ENABLE_IP6 uint32_t result; uint32_t n; IPCFG6_GET_ADDR_DATA data; char prn_addr6[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"]; #endif state = ipcfg_get_state (enet_device); if (state != IPCFG_STATE_INIT) { link = ipcfg_get_link_active (enet_device); task = ipcfg_task_status (); ipcfg_get_mac (enet_device, mac); ipcfg_get_ip (enet_device, &ip_data); #if RTCSCFG_IPCFG_ENABLE_DNS dns = ipcfg_get_dns_ip (enet_device, 0); #endif #if RTCSCFG_IPCFG_ENABLE_BOOT tftp_serveraddress = ipcfg_get_tftp_serveraddress (enet_device); tftp_servername = ipcfg_get_tftp_servername (enet_device); boot_filename = ipcfg_get_boot_filename (enet_device); #endif printf ("Eth# : %d\n", enet_device); printf ("Link : %s\n", link ? "on" : "off"); printf ("MAC : %02x:%02x:%02x:%02x:%02x:%02x\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); #if RTCSCFG_ENABLE_IP4 printf ("IP4 : %d.%d.%d.%d Type: %s\n", IPBYTES(ip_data.ip), ipcfg_get_state_string (state) ); printf ("IP4 Mask : %d.%d.%d.%d\n", IPBYTES(ip_data.mask)); #if RTCSCFG_ENABLE_GATEWAYS printf ("IP4 Gate : %d.%d.%d.%d\n", IPBYTES(ip_data.gateway)); #endif #if RTCSCFG_IPCFG_ENABLE_DNS printf ("IP4 DNS : %d.%d.%d.%d\n", IPBYTES(dns)); #endif #endif /* RTCSCFG_ENABLE_IP4 */ /************************************************/ #if RTCSCFG_ENABLE_IP6 n = 0; while(!ipcfg6_get_addr(enet_device, n, &data)) { if(inet_ntop(AF_INET6,&data.ip_addr, prn_addr6, sizeof(prn_addr6))) { printf("IP6 : %s ",prn_addr6); /* IPv6 address state */ printf("State: "); switch(data.ip_addr_state) { case IP6_ADDR_STATE_PREFERRED: printf("PREFERRED "); break; case IP6_ADDR_STATE_TENTATIVE: printf("TENTATIVE "); break; case IP6_ADDR_STATE_NOT_USED: printf("NOT_USED "); break; default: printf("%d ", data.ip_addr_state); break; } /* IPv6 address type */ printf("Type: "); switch(data.ip_addr_type) { case IP6_ADDR_TYPE_MANUAL: printf("MANUAL\n"); break; case IP6_ADDR_TYPE_AUTOCONFIGURABLE: printf("AUTOCONFIGURABLE\n"); break; default: printf("%d\n", data.ip_addr_type); break; } } else { printf("IP6 : ERROR IP CONVERT\n"); } n++; } /* Print Scope ID.*/ printf("ScopeID : %d\n", ipcfg6_get_scope_id(enet_device)); #endif /* RTCSCFG_ENABLE_IP6 */ #if RTCSCFG_ENABLE_IP4 #if RTCSCFG_IPCFG_ENABLE_BOOT printf ("TFTP: %d.%d.%d.%d '%s'\n", IPBYTES(tftp_serveraddress), tftp_servername); printf ("BOOT: '%s'\n", boot_filename); #endif #endif /* RTCSCFG_ENABLE_IP4 */ printf ("Link status task %s\n", task ? "running" : "stopped"); } else { printf ("Ethernet device %d not yet initialized.\n", enet_device); } return SHELL_EXIT_SUCCESS; }
int_32 Shell_bootloader_tftp_client(int_32 argc, char_ptr argv[] ) { _ip_address hostaddr; char hostname[MAX_HOSTNAMESIZE]; char_ptr file_ptr; uint_32 tftp_handle, buffer_size,byte_number=0,bytes=0; uchar_ptr buffer_ptr; TFTP_DATA_STRUCT tftp_data; MQX_FILE_PTR fd; int_32 error; boolean print_usage, shorthelp = FALSE; int_32 return_code = SHELL_EXIT_SUCCESS; int_32 i=0,address; print_usage = Shell_check_help_request(argc, argv, &shorthelp ); if (!print_usage) { if ((argc >= 3) && (argc <= 5)) { RTCS_resolve_ip_address( argv[1], &hostaddr, hostname, MAX_HOSTNAMESIZE ); if (!hostaddr) { printf("Unable to resolve host.\n"); return_code = SHELL_EXIT_ERROR; } else { tftp_data.SERVER = hostaddr; tftp_data.FILENAME = argv[2]; tftp_data.FILEMODE = argv[2]; if (argc > 3) { file_ptr = argv[3]; if (argc > 4) { tftp_data.FILEMODE = argv[4]; } else { tftp_data.FILEMODE = argv[2]; } } else { file_ptr = argv[2]; } address = StrtoHex(argv[3]); _image_data[0] = 0x00; printf("\nDownloading file %s from TFTP server: %s [%ld.%ld.%ld.%ld]\n", tftp_data.FILENAME,hostname, IPBYTES(hostaddr)); tftp_handle = (*FT_TFTP->OPEN)( (pointer) &tftp_data ); if ( tftp_handle != RTCS_OK ) { printf("\nError opening file %s\n",tftp_data.FILENAME); return_code = SHELL_EXIT_ERROR; } else { while (! (*FT_TFTP->EOFT)()) { while(1) { buffer_ptr = (*FT_TFTP->READ)( &buffer_size ); if (buffer_ptr != NULL) { for(i=0;i<(buffer_size);i++) { _image_data[i+byte_number]=buffer_ptr[i]; } byte_number += buffer_size; if(byte_number&0x1000) printf("#"); } else { switch (buffer_size) { case (RTCSERR_TFTP_ERROR + 1): printf("\nFile %s not found\n", tftp_data.FILENAME); break; case (RTCSERR_TFTP_ERROR + 2): printf("\nAccess violation\n"); break; case (RTCSERR_TFTP_ERROR + 3): printf("\nDisk full or allocation exceeded\n"); break; case (RTCSERR_TFTP_ERROR + 4): printf("\nIllegal TFTP operation\n"); break; case (RTCSERR_TFTP_ERROR + 5): printf("\nUnknown transfer ID\n"); break; case (RTCSERR_TFTP_ERROR + 6): printf("\nFile already exists\n"); break; case (RTCSERR_TFTP_ERROR + 7): printf("\nNo such user\n"); break; default: if(byte_number !=0) { printf("\nTransfer 0x%x byte success",byte_number); if(MQX_OK == _bootloader_store_image(address, byte_number, _image_data,(uchar_ptr)tftp_data.FILEMODE)) { printf("\nWrite image to table Success\n"); _bootloader_list_image(); } else { printf("\nWrite image to table Fail\n"); } break; } else printf("\nError reading file %s\n", tftp_data.FILENAME); } /* Endswitch */ break; } } } error = (*FT_TFTP->CLOSE)(); } tftp_handle = (*FT_TFTP->OPEN)( (pointer) &tftp_data ); if ( tftp_handle != RTCS_OK ) { printf("\nError opening file %s\n",tftp_data.FILENAME); return_code = SHELL_EXIT_ERROR; } error = (*FT_TFTP->CLOSE)(); } } else { printf("Error, %s invoked with incorrect number of arguments\n", argv[0]); print_usage = TRUE; } } if (print_usage) { if (shorthelp) { printf("%s <host> <source> <add> [<name>]\n", argv[0]); } else { printf("Usage: %s <host> <source> <add> [<name>]\n", argv[0]); printf(" <host> = TFTP server address or name\n"); printf(" <source> = Source file name\n"); printf(" <add> = Start address (Rom address in Linker file) \n"); printf(" [<name>] = Name of image will be stored in table \n"); } } return return_code; } /* Endbody */
/*TASK*----------------------------------------------------------------- * * Function Name : main_task * Returned Value : void * Comments : * *END------------------------------------------------------------------*/ void main_task(uint_32 temp) { int_32 error; HTTPD_STRUCT *server[BSP_ENET_DEVICE_COUNT]; extern const HTTPD_CGI_LINK_STRUCT cgi_lnk_tbl[]; extern const TFS_DIR_ENTRY tfs_data[]; HTTPD_PARAMS_STRUCT *params[BSP_ENET_DEVICE_COUNT]; _enet_address address[BSP_ENET_DEVICE_COUNT]; uint_32 phy_addr[BSP_ENET_DEVICE_COUNT]; uint_32 ip_addr[BSP_ENET_DEVICE_COUNT]; uint_32 i = 0; char* indexes[BSP_ENET_DEVICE_COUNT]; uint_8 n_devices = BSP_ENET_DEVICE_COUNT; #if DEMOCFG_USE_WIFI ENET_ESSID ssid; uint_32 mode;// = DEMOCFG_NW_MODE; uint_32 sectype;// = DEMOCFG_SECURITY; ENET_MEDIACTL_PARAM param; #endif #if RTCSCFG_ENABLE_IP6 IPCFG6_GET_ADDR_DATA data[RTCSCFG_IP6_IF_ADDRESSES_MAX]; char prn_addr6[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"]; uint_32 n = 0; uint_32 j = 0; #endif _int_install_unexpected_isr(); /*---------------- Initialize devices and variables ----------------------*/ _RTCSPCB_init = 4; _RTCSPCB_grow = 2; _RTCSPCB_max = 8; _RTCSTASK_stacksize = 4500; /*--------------------------- Init end -----------------------------------*/ PORT_PCR_REG(PORTC_BASE_PTR, 3) = PORT_PCR_MUX(5); // SIM_SOPT2 |= 3<<5; // 1k LPO error = RTCS_create(); if (error != RTCS_OK) { printf("RTCS failed to initialize, error = 0x%X\n", error); _task_block(); } _IP_forward = TRUE; for (i = 0; (i < n_devices) && (n_devices != 0); i++) { IPCFG_IP_ADDRESS_DATA ip_data; phy_addr[i] = i; ip_addr[i] = IPADDR(A,B,C+i,D); ENET_get_mac_address (phy_addr[i], ip_addr[i], address[i]); /* Init ENET device */ error = ipcfg_init_device (phy_addr[i], address[i]); if (error != RTCS_OK) { printf("IPCFG: Device n.%d init failed. Error = 0x%X\n", i, error); _task_set_error(MQX_OK); n_devices--; i--; continue; } #if RTCSCFG_ENABLE_IP4 ip_data.ip = ip_addr[i]; ip_data.mask = ENET_IPMASK; ip_data.gateway = 0; /* Bind IPv4 address */ //error = ipcfg_bind_staticip (phy_addr[i], &ip_data); error = ipcfg_bind_autoip (phy_addr[i], &ip_data); if (error != RTCS_OK) { printf("\nIPCFG: Failed to bind IP address. Error = 0x%X", error); _task_block(); } #endif /* RTCSCFG_ENABLE_IP4 */ indexes[i] = (char*) _mem_alloc(sizeof("\\index_x.html")); } error = _io_tfs_install("tfs:", tfs_data); #if DEBUG__MESSAGES printf("Preparing http servers...\n"); #endif for (i = 0; i < n_devices; i++) { params[i] = httpd_default_params(NULL); params[i]->af = HTTP_INET_AF; //IPv4+IPv6, set connection family from config.h #if RTCSCFG_ENABLE_IP6 params[i]->if_scope_id = HTTP_SCOPE_ID; // set interface number here. 0 is any . #endif if (params[i]) { sprintf(indexes[i], "\\index.html", i); params[i]->root_dir = (HTTPD_ROOT_DIR_STRUCT*)root_dir; params[i]->index_page = indexes[i]; printf("Starting http server No.%d on IP", i); /* ** If there is only one interface listen on any IP address ** so address can change in runtime (DHCP etc.) */ #if RTCSCFG_ENABLE_IP4 if ((i == 0) && (n_devices == 1)) { params[i]->address = INADDR_ANY; } else { params[i]->address = ip_addr[i]; } /* Print active ip addresses */ printf(" %d.%d.%d.%d", IPBYTES(ip_addr[i])); #endif #if RTCSCFG_ENABLE_IP6 while(!ipcfg6_get_addr_info_n(i, n, &data[n])) { n++; } while(j < n) { if(inet_ntop(AF_INET6, &data[j++].ip_addr, prn_addr6, sizeof(prn_addr6))) { /* Print active ip addresses */ #if RTCSCFG_ENABLE_IP4 printf("%s %s", (HTTP_INET_AF & AF_INET) ? " and" : "", prn_addr6); #else printf(" %s", prn_addr6); #endif } } #endif #if PSP_MQX_CPU_IS_MCF5223X params[i]->max_ses = 1; #else params[i]->max_ses = _RTCS_socket_part_max - 1; #endif server[i] = httpd_init(params[i]); } HTTPD_SET_PARAM_CGI_TBL(server[i], (HTTPD_CGI_LINK_STRUCT*)cgi_lnk_tbl); #if HTTPD_SEPARATE_TASK || !HTTPDCFG_POLL_MODE printf("..."); error = httpd_server_run(server[i]); if (error) { printf("[FAIL]\n"); } else { printf("[OK]\n"); } #endif } /* user stuff come here */ #if HTTPD_SEPARATE_TASK || !HTTPDCFG_POLL_MODE _task_create(0, SHELL_TASK, 0); _task_block(); #else printf("Servers polling started.\n") while (1) { for (i = 0; i < n_devices; i++) { httpd_server_poll(server[i], 1); } /* user stuff come here - only non blocking calls */ } #endif }
void SEC_InitializeNetworking(uint_32 pcbs, uint_32 msgs, uint_32 sockets, boolean dhcp) { int_32 error; IPCFG_IP_ADDRESS_DATA ip_data; _enet_address enet_address; #if PSP_MQX_CPU_IS_MCF51CN _enet_handle ehandle; _rtcs_if_handle ihandle; #endif /* runtime RTCS configuration */ _RTCSPCB_init = pcbs; _RTCS_msgpool_init = msgs; _RTCS_socket_part_init = sockets; error = RTCS_create(); if (error == RTCS_OK) { ip_data.ip = ENET_IPADDR; ip_data.mask = ENET_IPMASK; ip_data.gateway = ENET_IPGATEWAY; #if RTCSCFG_ENABLE_LWDNS LWDNS_server_ipaddr = ENET_IPDNS; #endif ENET_get_mac_address(BSP_DEFAULT_ENET_DEVICE, ENET_IPADDR, enet_address); #if PSP_MQX_CPU_IS_MCF51CN ENET_initialize_ex(&ENET_param, BSP_DEFAULT_ENET_DEVICE, &ehandle); if (RTCS_if_add(ehandle, RTCS_IF_ENET, &ihandle) == 0) { if (ipcfg_init_interface(-1, ihandle) != 0) { RTCS_if_remove(ihandle); ENET_shutdown(ehandle); _task_block(); } } else { ENET_shutdown(ehandle); } #else ipcfg_init_device(BSP_DEFAULT_ENET_DEVICE, enet_address); #endif ipcfg_add_dns_ip(BSP_DEFAULT_ENET_DEVICE,LWDNS_server_ipaddr); // check link status printf("\nWaiting for ethernet cable plug in ... "); while(!ipcfg_get_link_active(BSP_DEFAULT_ENET_DEVICE)) {}; printf("Cable connected\n"); /* If DHCP Enabled, get IP address from DHCP server */ if (dhcp) { printf("\nDHCP bind ... "); error = ipcfg_bind_dhcp_wait(BSP_DEFAULT_ENET_DEVICE, 1, &ip_data); if (error != IPCFG_ERROR_OK) { printf("Error %08x!\n", error); } else { printf("Successful!\n"); } } else { /* Else bind with static IP */ printf ("\nStatic IP bind ... "); error = ipcfg_bind_staticip(BSP_DEFAULT_ENET_DEVICE, &ip_data); if (error != IPCFG_ERROR_OK) { printf("Error %08x!\n",error); } else { printf("Successful!\n"); } } if (error == IPCFG_ERROR_OK) { ipcfg_get_ip(BSP_DEFAULT_ENET_DEVICE, &ip_data); printf("\nIP Address : %d.%d.%d.%d\n",IPBYTES(ip_data.ip)); printf("\nSubnet Address : %d.%d.%d.%d\n",IPBYTES(ip_data.mask)); printf("\nGateway Address : %d.%d.%d.%d\n",IPBYTES(ip_data.gateway)); printf("\nDNS Address : %d.%d.%d.%d\n",IPBYTES(ipcfg_get_dns_ip(BSP_DEFAULT_ENET_DEVICE,0))); } } else { printf("\nRTCS_Create failed !\n"); _task_block(); } SEC_GetTime(); }
int_32 Shell_exec(int_32 argc, char_ptr argv[] ) { /* Body */ _ip_address hostaddr; char hostname[MAX_HOSTNAMESIZE]; char_ptr host_ptr , file_ptr, format_ptr; boolean print_usage, shorthelp = FALSE; int_32 error = 0, return_code = SHELL_EXIT_SUCCESS; print_usage = Shell_check_help_request(argc, argv, &shorthelp ); if (!print_usage) { if (argc > 4 ) { printf("Error, %s invoked with incorrect number of arguments\n", argv[0]); print_usage = TRUE; return_code = SHELL_EXIT_ERROR; } else { format_ptr = "srec"; if (argc > 1) { file_ptr = argv[1]; if (argc > 2) { host_ptr = argv[2]; if (argc>3) { format_ptr = argv[3]; } } else { printf("Error, no TFTP Server specified.\n", argv[0]); print_usage = TRUE; return_code = SHELL_EXIT_ERROR; } } else { printf("Error, no bootfile specified.\n", argv[0]); print_usage = TRUE; return_code = SHELL_EXIT_ERROR; } } if (return_code != SHELL_EXIT_ERROR) { RTCS_resolve_ip_address( host_ptr, &hostaddr, hostname, MAX_HOSTNAMESIZE ); if (hostaddr) { printf("Loading %s from %s [%ld.%ld.%ld.%ld]:\n", file_ptr, hostname, IPBYTES(hostaddr)); if (strcmp(format_ptr, "srec") == 0) { error = RTCS_exec_TFTP_SREC(hostaddr, file_ptr); } else if (strcmp(format_ptr, "coff") == 0) { error = RTCS_exec_TFTP_COFF(hostaddr, file_ptr); } else { printf("Error, invalid format %s\n", format_ptr); print_usage = TRUE; return_code = SHELL_EXIT_ERROR; } if (error) { printf("RTCS_exec_TFTP_%s returned with error code = %x\n",format_ptr, error); return_code = SHELL_EXIT_ERROR; } } else { printf("Unable to resolve host\n"); return_code = SHELL_EXIT_ERROR; } } } if (print_usage) { if (shorthelp) { printf("%s <file> <host> <format>\n", argv[0]); } else { printf("Usage: %s <file> <host> <format>\n", argv[0]); printf(" <file> = filename\n"); printf(" <host> = TFTP Server ip address or name\n"); printf(" <format> = file format, one of coff or srec\n"); } } return return_code; } /* Endbody */
/*FUNCTION*------------------------------------------------ * * Function Name: shell_ppp_start() * Comments : * This function start PPP communication and try to establish PPP connection. *END*-----------------------------------------------------*/ void shell_ppp_start(SHELL_PPP_LINK_PTR ppp_current) { uint_32 error; _ip_address local_address; _ip_address peer_address=0; IPCP_DATA_STRUCT ipcp_data; /* This is configuration for PAP. */ char* localname = ppp_current->LOCAL_NAME; char* localsecret = ppp_current->LOCAL_PASSWORD; PPP_SECRET lsecret; if(default_ppp.SERVER_FLAG==0) { /* Setup PAP for client mode.*/ lsecret.PPP_ID_LENGTH = strlen(localname); lsecret.PPP_PW_LENGTH = strlen(localsecret); lsecret.PPP_ID_PTR = localname; lsecret.PPP_PW_PTR = localsecret; _PPP_PAP_LSECRET = &lsecret; /* lsecrets */ _PPP_PAP_RSECRETS = NULL; /* rsecrets */ _PPP_CHAP_LNAME = NULL; /* localname */ _PPP_CHAP_LSECRETS = NULL; /* lsecrets */ _PPP_CHAP_RSECRETS = NULL; /* rsecrets */ } else if(default_ppp.SERVER_FLAG==1) { /* Setup PAP for server mode.*/ _PPP_PAP_LSECRET = NULL; /* lsecrets */ _PPP_PAP_RSECRETS = ppp_current->rsecrets; /* rsecrets */ _PPP_CHAP_LNAME = NULL; /* localname */ _PPP_CHAP_LSECRETS = NULL; /* lsecrets */ _PPP_CHAP_RSECRETS = NULL; /* rsecrets */ } else { ppp_current->PPP_HANDLE = NULL; return; } /* Install a route for a default gateway */ RTCS_gate_add(ppp_current->PPP_GATE_ADDR, INADDR_ANY, INADDR_ANY); ppp_current->PPP_IO_DRIVER_HANDLE = _iopcb_ppphdlc_init(ppp_current->PPP_DEV_HANDLE); _PPP_ACCM = 0; error = PPP_initialize(ppp_current->PPP_IO_DRIVER_HANDLE, &ppp_current->PPP_HANDLE); if (error) { printf("\n PPP initialize: %lx", error); _task_block(); } _iopcb_open(ppp_current->PPP_IO_DRIVER_HANDLE, PPP_lowerup, PPP_lowerdown,ppp_current->PPP_HANDLE); error = RTCS_if_add(ppp_current->PPP_HANDLE, RTCS_IF_PPP, &ppp_current->PPP_IF_HANDLE); if (error) { printf("\n IF add failed, error = %lx", error); _task_block(); } _lwsem_create(&ppp_current->PPP_SEM, 0); _mem_zero(&ipcp_data, sizeof(ipcp_data)); ipcp_data.IP_UP = PPP_linkup; ipcp_data.IP_DOWN = PPP_linkdown; ipcp_data.IP_PARAM = &ppp_current->PPP_SEM; if(default_ppp.SERVER_FLAG==0) { ipcp_data.ACCEPT_LOCAL_ADDR = TRUE; ipcp_data.ACCEPT_REMOTE_ADDR = TRUE; } else { ipcp_data.ACCEPT_LOCAL_ADDR = FALSE; ipcp_data.ACCEPT_REMOTE_ADDR = FALSE; } ipcp_data.LOCAL_ADDR = ppp_current->PPP_LOCAL_ADDRESS; ipcp_data.REMOTE_ADDR = ppp_current->PPP_REMOTE_ADDRESS; ipcp_data.DEFAULT_NETMASK = TRUE; ipcp_data.DEFAULT_ROUTE = TRUE; error = RTCS_if_bind_IPCP(ppp_current->PPP_IF_HANDLE, &ipcp_data); if (error) { printf("\n IF bind failed, error = %lx", error); _task_block(); } /*In case "client" we need wait for connection to server*/ if(default_ppp.SERVER_FLAG==0) { printf("\n Please wait initiate PPP connection. Waiting...\n"); /*Handshake with RAS server */ /* 10 attempts to connect */ error = 0; while (error < 10) { if (PPP_link == FALSE) { _time_delay(1000); } else { printf("\n PPP_link = %d, time = %d\n",PPP_link,error); break; } error ++; } if (PPP_link == TRUE) { local_address = IPCP_get_local_addr(ppp_current->PPP_IF_HANDLE); peer_address = IPCP_get_peer_addr(ppp_current->PPP_IF_HANDLE); printf("\n PPP device on %s is bound on.\n", ppp_current->PPP_CONNECTION_DEVICE ); printf(" PPP local address is : %d.%d.%d.%d\n", IPBYTES(local_address)); printf(" PPP remote address is : %d.%d.%d.%d\n", IPBYTES(peer_address)); printf(" Now PPP connection is established on %d.%d.%d.%d\n", IPBYTES(peer_address)); } else { if(ppp_current->PPP_HANDLE) { /* clean up all PPP structure */ error = PPP_shutdown(ppp_current->PPP_HANDLE); } ppp_current->PPP_HANDLE = NULL; /* We shoul remove route to clear part block. */ RTCS_gate_remove(ppp_current->PPP_GATE_ADDR, INADDR_ANY, INADDR_ANY); } } else { /* In case of "server" we do not need wait at all. */ printf("\n PPP server ready and waiting for connection.\n"); } }
int_32 Shell_dnat(int_32 argc, char_ptr argv[] ) { uint_32 error; boolean print_usage, shorthelp = FALSE; int_32 return_code = SHELL_EXIT_SUCCESS; uint_32 priority=0; uint_16 protocol=0; uint_16 start_port=0; uint_16 end_port=0; _ip_address target_ip=0; uint_16 target_port=0; print_usage = Shell_check_help_request(argc, argv, &shorthelp ); if (!print_usage) { if (argc == 7) { if (!Shell_parse_uint_32(argv[1], &priority )) { printf("Error, invalid rule priority\n"); return_code = SHELL_EXIT_ERROR; } else if (!Shell_parse_uint_16(argv[3], &start_port )) { printf("Error, invalid start port\n"); return_code = SHELL_EXIT_ERROR; } else if (!Shell_parse_uint_16(argv[4], &end_port )) { printf("Error, invalid end port\n"); return_code = SHELL_EXIT_ERROR; } else if (! Shell_parse_ip_address( argv[5], &target_ip )) { printf("Error, invalid ip address\n"); return_code = SHELL_EXIT_ERROR; } else if (!Shell_parse_uint_16(argv[6], &target_port )) { printf("Error, invalid target port\n"); return_code = SHELL_EXIT_ERROR; } else { if (strcmp(argv[2],"TCP")==0) { protocol = IPPROTO_TCP; } else if (strcmp(argv[2],"UDP")==0) { protocol = IPPROTO_UDP; } else { printf("Error, invalid protocol\n"); return_code = SHELL_EXIT_ERROR; } } if (return_code == SHELL_EXIT_SUCCESS) { printf("Adding rule:\n"); printf("%d: %s (%d-%d) -> %03d.%03d.%03d.%03d:%d", priority, protocol==IPPROTO_TCP?"TCP":"UDP",start_port,end_port, IPBYTES(target_ip), target_port); error = DNAT_add_rule(priority, protocol, start_port, end_port, target_ip, target_port ); if (error != RTCS_OK) { printf(" Error: %s\n",NAT_err_str(error)); return_code = SHELL_EXIT_ERROR; } else { printf(" OK\n"); } } } else { print_usage = TRUE; return_code = SHELL_EXIT_ERROR; } } if (print_usage) { if (shorthelp) { printf("%s <priority> TCP|UDP <start_port> <end_port> <target_ip> <target_port>\n", argv[0]); } else { printf("Usage: %s <priority> TCP|UDP <start_port> <end_port> <target_ip> <target_port>\n",argv[0]); } } return return_code; } /* Endbody */
int_32 Shell_natinfo(int_32 argc, char_ptr argv[] ) { boolean print_usage, shorthelp = FALSE; int_32 i , return_code = SHELL_EXIT_SUCCESS; uint_32 natinfo = 0, num_nets; NAT_STATS_PTR nat_stats_ptr = NULL; NAT_NETWORK_STRUCT_PTR nat_network_ptr = NULL; boolean continuous = FALSE; uint_32 priority; uint_16 start_port; uint_16 end_port; _ip_address target_ip; uint_16 target_port; uint_16 protocol; uint_32 result; NAT_SESSION_STRUCT_PTR session_ptr; print_usage = Shell_check_help_request(argc, argv, &shorthelp ); if (!print_usage) { if (argc==1) { natinfo = NATINFO_ALL; } else { for (i=1;i<argc;i++) { if (strcmp(argv[i],"stats")==0) { natinfo |= NATINFO_STATS; } else if (strcmp(argv[i],"rules")==0) { natinfo |= NATINFO_RULES; } else if (strcmp(argv[i],"networks")==0) { natinfo |= NATINFO_NETWORKS; } else if (strcmp(argv[i],"all")==0) { natinfo |= NATINFO_ALL; } else if (strcmp(argv[i],"loop")==0) { continuous = TRUE; } else { print_usage = TRUE; return_code = SHELL_EXIT_ERROR; } } } if (return_code == SHELL_EXIT_SUCCESS) { do { if (natinfo & NATINFO_STATS) { nat_stats_ptr= NAT_stats(); if (nat_stats_ptr == NULL) { printf("NAT statistics not available.\n"); return_code = SHELL_EXIT_ERROR; } else { printf("NAT Statistics:\n"); printf(" ST_SESSIONS: 0x%08x\n", nat_stats_ptr->ST_SESSIONS ); printf(" ST_SESSIONS_SNAT: 0x%08x\n", nat_stats_ptr->ST_SESSIONS_SNAT ); printf(" ST_SESSIONS_DNAT: 0x%08x\n", nat_stats_ptr->ST_SESSIONS_DNAT ); printf(" ST_SESSIONS_OPEN: 0x%08x\n", nat_stats_ptr->ST_SESSIONS_OPEN ); printf(" ST_SESSIONS_OPEN_MAX: 0x%08x\n", nat_stats_ptr->ST_SESSIONS_OPEN_MAX ); printf(" ST_PACKETS_TOTAL: 0x%08x\n", nat_stats_ptr->ST_PACKETS_TOTAL ); printf(" ST_PACKETS_BYPASS: 0x%08x\n", nat_stats_ptr->ST_PACKETS_BYPASS ); printf(" ST_PACKETS_PUB_PRV: 0x%08x\n", nat_stats_ptr->ST_PACKETS_PUB_PRV ); printf(" ST_PACKETS_PUB_PRV_ERR: 0x%08x\n", nat_stats_ptr->ST_PACKETS_PUB_PRV_ERR ); printf(" ST_PACKETS_PRV_PUB: 0x%08x\n", nat_stats_ptr->ST_PACKETS_PRV_PUB ); printf(" ST_PACKETS_PRV_PUB_ERR: 0x%08x\n", nat_stats_ptr->ST_PACKETS_PRV_PUB_ERR ); printf(" ST_PACKETS_FRAGMENTS: 0x%08x\n", nat_stats_ptr->ST_PACKETS_FRAGMENTS ); printf(" ST_PACKETS_REASSEMBLED: 0x%08x\n", nat_stats_ptr->ST_PACKETS_REASSEMBLED ); printf(" ST_PACKETS_REASSSEMBLY_ERR: 0x%08x\n", nat_stats_ptr->ST_PACKETS_REASSSEMBLY_ERR ); } } if (natinfo & NATINFO_RULES) { priority=0; result = DNAT_get_next_rule(&priority,&protocol,&start_port,&end_port, &target_ip,&target_port); if (result==RTCS_OK) { printf("NAT Rules:\n"); while (result==RTCS_OK) { printf("%d: %s (%d-%d) -> %03d.%03d.%03d.%03d:%d\n", priority, protocol==IPPROTO_TCP?"TCP":"UDP",start_port,end_port, IPBYTES(target_ip), target_port); result = DNAT_get_next_rule(&priority,&protocol,&start_port,&end_port, &target_ip,&target_port); } } else { printf("NAT Rule data not available.\n"); return_code = SHELL_EXIT_ERROR; } } if (natinfo & NATINFO_NETWORKS) { nat_network_ptr= NAT_networks(); if (nat_network_ptr == NULL) { printf("NAT Network data not available.\n"); return_code = SHELL_EXIT_ERROR; } else { printf("NAT Networks:\n"); for (num_nets=0;num_nets<nat_network_ptr->NUM_PRV_NETS;num_nets++) { printf(" %2d: %03d.%03d.%03d.%03d %03d.%03d.%03d.%03d \n", num_nets, IPBYTES(nat_network_ptr->PRV_NET[num_nets]), IPBYTES(nat_network_ptr->PRV_MASK[num_nets])); } for (num_nets=nat_network_ptr->NUM_PRV_NETS;num_nets<NAT_MAX_PRIVATE_NETWORKS;num_nets++) { if ((nat_network_ptr->PRV_NET[num_nets]!=0) || (nat_network_ptr->PRV_MASK[num_nets])) { printf(" Invalid Entry:\n %2d: %03d.%03d.%03d.%03d %03d.%03d.%03d.%03d \n", num_nets, IPBYTES(nat_network_ptr->PRV_NET[num_nets]), IPBYTES(nat_network_ptr->PRV_MASK[num_nets])); } } } } if (natinfo & NATINFO_SESSIONS) { printf("NAT Inbound sessions:\n"); session_ptr = (NAT_SESSION_STRUCT_PTR) NAT_find_next_session(NULL, 0); while (session_ptr!=NULL) { printf("%s-%s: %d.%d.%d.%d:%d -> %d.%d.%d.%d:%d -> %d.%d.%d.%d:%d [%d]\n", session_ptr->SNAT_OR_DNAT==SNAT?"SNAT":"DNAT", IP_Prot_str(session_ptr->IP_PROT), IPBYTES(session_ptr->PUB_HST), session_ptr->PUB_PORT, IPBYTES(session_ptr->NAT_HST), session_ptr->NAT_PORT, IPBYTES(session_ptr->PRV_HST), session_ptr->PRV_PORT, session_ptr->TIMEOUT.TIME); session_ptr = (NAT_SESSION_STRUCT_PTR) NAT_find_next_session((pointer)session_ptr, 0); } printf("NAT Outbound sessions:\n"); session_ptr = (NAT_SESSION_STRUCT_PTR) NAT_find_next_session(NULL, 1); while (session_ptr!=NULL) { printf("%s-%s: %d.%d.%d.%d:%d -> %d.%d.%d.%d:%d -> %d.%d.%d.%d:%d [%d]\n", session_ptr->SNAT_OR_DNAT==SNAT?"SNAT":"DNAT", IP_Prot_str(session_ptr->IP_PROT), IPBYTES(session_ptr->PRV_HST), session_ptr->PRV_PORT, IPBYTES(session_ptr->NAT_HST), session_ptr->NAT_PORT, IPBYTES(session_ptr->PUB_HST), session_ptr->PUB_PORT, session_ptr->TIMEOUT.TIME); session_ptr = (NAT_SESSION_STRUCT_PTR) NAT_find_next_session((pointer)session_ptr, 1); } } if (continuous) { if (status()) { continuous = FALSE; } else { _time_delay(1000); } } } while (continuous); } } if (print_usage) { if (shorthelp) { printf("%s [stats|rules|networks|all|loop]\n", argv[0]); } else { printf("Usage: %s [stats|rules|networks|all|loop]\n",argv[0]); } } return return_code; } /* Endbody */
int_32 Shell_TFTP_client(int_32 argc, char_ptr argv[] ) { _ip_address hostaddr; char hostname[MAX_HOSTNAMESIZE]=""; char_ptr file_ptr; uint_32 tftp_handle, buffer_size,byte_number; uchar_ptr buffer_ptr; TFTP_DATA_STRUCT tftp_data; MQX_FILE_PTR fd; int_32 error; boolean print_usage, shorthelp = FALSE; int_32 return_code = SHELL_EXIT_SUCCESS; char path[SHELL_MAX_FILELEN]; boolean trans = FALSE; print_usage = Shell_check_help_request(argc, argv, &shorthelp ); if (!print_usage) { if ((argc >= 3) && (argc <= 5)) { RTCS_resolve_ip_address( argv[1], &hostaddr, hostname, MAX_HOSTNAMESIZE ); if (!hostaddr) { printf("Unable to resolve host.\n"); return_code = SHELL_EXIT_ERROR; } else { tftp_data.SERVER = hostaddr; tftp_data.FILENAME = argv[2]; tftp_data.FILEMODE = "netascii"; if (argc > 3) { file_ptr = argv[3]; if (argc > 4) { tftp_data.FILEMODE = argv[4]; } else { tftp_data.FILEMODE = "netascii"; } } else { file_ptr = argv[2]; } #if SHELLCFG_USES_MFS Shell_create_prefixed_filename(path, file_ptr, argv); fd = fopen(path,"a"); if (fd) { printf("\nDownloading file %s from TFTP server: %s [%ld.%ld.%ld.%ld]\n", tftp_data.FILENAME,hostname, IPBYTES(hostaddr)); tftp_handle = (*FT_TFTP->OPEN)( (pointer) &tftp_data ); if ( tftp_handle != RTCS_OK ) { printf("\nError opening file %s\n",tftp_data.FILENAME); return_code = SHELL_EXIT_ERROR; } else { if (! (*FT_TFTP->EOFT)()) { do { buffer_ptr = (*FT_TFTP->READ)( &buffer_size ); if ((buffer_ptr != NULL) && (buffer_size)) { fseek(fd, 0 , IO_SEEK_CUR); _io_write(fd,buffer_ptr,buffer_size); trans = TRUE; } else { switch (buffer_size) { case 0: // end of file break; case (RTCSERR_TFTP_ERROR + 1): printf("\nFile %s not found\n", tftp_data.FILENAME); break; case (RTCSERR_TFTP_ERROR + 2): printf("\nAccess violation\n"); break; case (RTCSERR_TFTP_ERROR + 3): printf("\nDisk full or allocation exceeded\n"); break; case (RTCSERR_TFTP_ERROR + 4): printf("\nIllegal TFTP operation\n"); break; case (RTCSERR_TFTP_ERROR + 5): printf("\nUnknown transfer ID\n"); break; case (RTCSERR_TFTP_ERROR + 6): printf("\nFile already exists\n"); break; case (RTCSERR_TFTP_ERROR + 7): printf("\nNo such user\n"); break; default: if(trans) { trans =FALSE; break; } else printf("\nError reading file %s\n", tftp_data.FILENAME); } /* Endswitch */ } } while((buffer_ptr !=NULL) && buffer_size && (! (*FT_TFTP->EOFT)()) ); fclose(fd); } error = (*FT_TFTP->CLOSE)(); } } else { printf("\nError opening local file %s\n",file_ptr); return_code = SHELL_EXIT_ERROR; } #else tftp_handle = (*FT_TFTP->OPEN)( (pointer) &tftp_data ); if ( tftp_handle != RTCS_OK ) { printf("\nError opening file %s\n",tftp_data.FILENAME); return_code = SHELL_EXIT_ERROR; } else { printf("SHELLCFG_USES_MFS is not set to 1 in user_config.h - file wont be written to disk\n"); } error = (*FT_TFTP->CLOSE)(); #endif } } else { printf("Error, %s invoked with incorrect number of arguments\n", argv[0]); print_usage = TRUE; } } if (print_usage) { if (shorthelp) { printf("%s <host> <source> [<dest>] [<mode>]\n", argv[0]); } else { printf("Usage: %s <host> <source> [<dest>] [<mode>]\n", argv[0]); printf(" <host> = host ip address or name\n"); printf(" <source> = remote file name\n"); printf(" <dest> = local file name\n"); printf(" <mode> = file transfer mode (netascii, etc.)\n"); } } return return_code; } /* Endbody */
void SEC_EmailAlert() { MQX_TICK_STRUCT ticks; MQX_XDATE_STRUCT xdate; sockaddr addr; _ip_address ipaddr; uint_32 sock; uint_32 error; uint_32 option; char_ptr event_ptr; char temp[150]; char domain[30]; char user[30]; #if DEMOCFG_AUTH_REQUIRED char temp_encoded[40]; #endif if (!RTCS_resolve_ip_address(EMAIL_SERVER,&ipaddr,NULL,0)) { printf("Error resolving IP address for %s using DNS Server at %d.%d.%d.%d\n", EMAIL_SERVER, IPBYTES(ipcfg_get_dns_ip(BSP_DEFAULT_ENET_DEVICE, 0))); return; } /* Create socket */ sock = socket(AF_INET, SOCK_STREAM, 0); if (sock == RTCS_SOCKET_ERROR) { printf("Error creating socket\n"); return; } /* Reduce buffer size of socket to save memory */ option = SMTP_BUFFER_SIZE; error = setsockopt(sock, SOL_TCP, OPT_TBSIZE, &option, sizeof(option)); option = SMTP_BUFFER_SIZE; error = setsockopt(sock, SOL_TCP, OPT_RBSIZE, &option, sizeof(option)); option = 1000; error = setsockopt(sock, SOL_TCP, OPT_TIMEWAIT_TIMEOUT, &option, sizeof(option)); /* Allow binding to any address */ #if RTCSCFG_ENABLE_IP4 ((sockaddr_in*)(&addr))->sin_family = AF_INET; ((sockaddr_in*)(&addr))->sin_port = 0; ((sockaddr_in*)(&addr))->sin_addr.s_addr = INADDR_ANY; #elif RTCSCFG_ENABLE_IP6 printf("\nThis application don't support IPv6 only.\n"); _task_block(); #endif error = bind(sock, &addr, sizeof(addr)); if (error != RTCS_OK) { printf("Error in binding socket %08x\n",error); shutdown(sock, FLAG_ABORT_CONNECTION); return; } /* Connect to SMTP server */ #if RTCSCFG_ENABLE_IP4 ((sockaddr_in*)(&addr))->sin_port = IPPORT_SMTP; ((sockaddr_in*)(&addr))->sin_addr.s_addr = ipaddr; #elif RTCSCFG_ENABLE_IP6 printf("\nThis application does not support IPv6 only.\n"); _task_block(); #endif error = connect(sock, &addr, sizeof(addr)); if (error != RTCS_OK) { printf("Error in connection %08x\n",error); shutdown(sock, FLAG_ABORT_CONNECTION); return; } printf("\nConnecting to SMTP server %s...\n",EMAIL_SERVER); printf("SMTP Server Response:\n"); SMTP_Receive_string(sock, temp, sizeof(temp)); /* Follow SMTP protocol to send email */ /* Parse domain name from the FROM address, for use with the EHLO or HELO commands */ sscanf(EMAIL_FROM,"%30s@%30s",user,domain); #if DEMOCFG_AUTH_REQUIRED /* If Authentification is required, use EHLO command */ SMTP_Send_command(sock, "EHLO", domain, temp, sizeof(temp)); SMTP_Send_command(sock,"AUTH LOGIN",NULL,temp,sizeof(temp)); /* Find base64 econding of login name and send to SMTP server */ sprintf(temp,"%s\r\n",base64_encode(AUTH_USERNAME,temp_encoded)); SMTP_Send_string(sock,temp); SMTP_Receive_string(sock,temp,sizeof(temp)-1); /* Find base64 econding of password and send to SMTP server */ sprintf(temp,"%s\r\n",base64_encode(AUTH_PASSWORD,temp_encoded)); SMTP_Send_string(sock,temp); SMTP_Receive_string(sock,temp, sizeof(temp)-1); #else /* If Authentification is not required, use HELO command as not all servers recognize EHLO */ SMTP_Send_command(sock, "HELO", domain, temp, sizeof(temp)); #endif /* Transfer sender email address to server */ SMTP_Send_command(sock,"MAIL FROM:","<" EMAIL_FROM ">" ,temp,sizeof(temp)); /* Transfer recipient email address to server */ SMTP_Send_command(sock,"RCPT TO:","<" EMAIL_TO ">" ,temp,sizeof(temp)); /* Start DATA section */ SMTP_Send_command(sock,"DATA",NULL,temp,sizeof(temp)); printf("Sent:\n"); /* Send Subject, To, and From fields */ SMTP_Send_string(sock,(pointer)Email_header); /* Determine what to send as body of message */ _time_get_ticks(&ticks); _time_ticks_to_xdate(&ticks,&xdate); sprintf(temp, "Date: %s, %d %s %d %02d:%02d:%02d -0000\r\n\r\n", wday[xdate.WDAY],xdate.MDAY, months[xdate.MONTH-1],xdate.YEAR, xdate.HOUR, xdate.MIN, xdate.SEC ); SMTP_Send_string(sock,temp); /* If button pushed was the "Door"... */ if(SEC_Params.Status==SEC_DOOR_OPEN_STATUS) { event_ptr = "Door was opened "; } else /* If button pushed was the "Window"... */ if(SEC_Params.Status==SEC_WINDOW_OPEN_STATUS) { event_ptr = "Window was opened "; } /* If not sure what caused stop mode to exit... */ else { event_ptr = "Unknown event occurred "; } SMTP_Send_string(sock,event_ptr); /* If SNTP enabled, then send exact date and time button press happened */ #if DEMOCFG_ENABLE_SNTP sprintf(temp,"on %d/%d/%d at %02d:%02d:%02d GMT. \r\n",xdate.MONTH,xdate.MDAY,xdate.YEAR,xdate.HOUR,xdate.MIN,xdate.SEC); /* If SNTP not enabled, then give elapsed time instead */ #else sprintf(temp,"%02d:%02d:%02d after system was started. \r\n",xdate.HOUR,xdate.MIN,xdate.SEC); #endif SMTP_Send_string(sock,temp); if (last[0]) { /* Send out how long ago the last event was */ SMTP_Send_string(sock,"Previous event was "); SMTP_Send_string(sock,last); } strcpy(last,temp); /* Send Freescale signature and disconnect from server with QUIT command */ SMTP_Send_string(sock,"\r\n-Freescale Semiconductor\r\n.\r\n"); SMTP_Send_command(sock,"QUIT",NULL,temp,sizeof(temp)); /* Close socket */ shutdown(sock, FLAG_CLOSE_TX); }
void SEC_InitializeNetworking(uint_32 pcbs, uint_32 msgs, uint_32 sockets, boolean dhcp) { int_32 error; IPCFG_IP_ADDRESS_DATA ip_data; _enet_address enet_address; /* runtime RTCS configuration */ _RTCSPCB_init = pcbs; _RTCS_msgpool_init = msgs; _RTCS_socket_part_init = sockets; error = RTCS_create(); if (error == RTCS_OK) { ip_data.ip = ENET_IPADDR; ip_data.mask = ENET_IPMASK; ip_data.gateway = ENET_IPGATEWAY; ENET_get_mac_address(BSP_DEFAULT_ENET_DEVICE, ENET_IPADDR, enet_address); ipcfg_init_device(BSP_DEFAULT_ENET_DEVICE, enet_address); ipcfg_add_dns_ip(BSP_DEFAULT_ENET_DEVICE,LWDNS_server_ipaddr); // check link status printf("\nWaiting for ethernet cable plug in ... "); while(!ipcfg_get_link_active(BSP_DEFAULT_ENET_DEVICE)) {}; printf("Cable connected\n"); /* If DHCP Enabled, get IP address from DHCP server */ if (dhcp) { printf("\nDHCP bind ... "); error = ipcfg_bind_dhcp_wait(BSP_DEFAULT_ENET_DEVICE, 1, &ip_data); if (error != IPCFG_ERROR_OK) { printf("Error %08x!\n", error); } else { printf("Successful!\n"); } } else { /* Else bind with static IP */ printf ("\nStatic IP bind ... "); error = ipcfg_bind_staticip(BSP_DEFAULT_ENET_DEVICE, &ip_data); if (error != IPCFG_ERROR_OK) { printf("Error %08x!\n",error); } else { printf("Successful!\n"); } } if (error == IPCFG_ERROR_OK) { ipcfg_get_ip(BSP_DEFAULT_ENET_DEVICE, &ip_data); printf("\nIP Address : %d.%d.%d.%d\n",IPBYTES(ip_data.ip)); printf("\nSubnet Address : %d.%d.%d.%d\n",IPBYTES(ip_data.mask)); printf("\nGateway Address : %d.%d.%d.%d\n",IPBYTES(ip_data.gateway)); printf("\nDNS Address : %d.%d.%d.%d\n",IPBYTES(ipcfg_get_dns_ip(BSP_DEFAULT_ENET_DEVICE,0))); } } else { printf("\nRTCS_Create failed !\n"); _task_block(); } }
void rtcs_init() { IPCFG_IP_ADDRESS_DATA ip_data; _enet_address enet_address; uint_32 error = RTCS_create(); if (error != RTCS_OK) { printf("\nRTCS failed to initialize, error = %X", error); _task_block(); } _IP_forward = TRUE; #ifdef BSP_ENET_DEVICE_COUNT #if (BSP_ENET_DEVICE_COUNT > 0) /*Following section is relevant only in case there as some enet driver available in BSP (FEC, MACNET, WIFI or other enet driver)*/ ip_data.ip = ENET_IPADDR; ip_data.mask = ENET_IPMASK; ip_data.gateway = ENET_GATEWAY; /* calcualte unique mac address from IP ADDRES */ ENET_get_mac_address (ENET_DEVICE, ENET_IPADDR, enet_address); error = ipcfg_init_device (ENET_DEVICE, enet_address); if (error != RTCS_OK) { printf("\nFailed to initialize ethernet device, error = %X", error); _task_block(); } #if RTCSCFG_ENABLE_LWDNS LWDNS_server_ipaddr = ENET_GATEWAY; ipcfg_add_dns_ip(ENET_DEVICE,LWDNS_server_ipaddr); #endif /* RTCSCFG_ENABLE_LWDNS */ printf("\nWaiting for ethernet cable plug in ... "); while(!ipcfg_get_link_active(ENET_DEVICE)) {}; printf("Cable connected\n"); #if RTCS_DHCP printf("Contacting DHCP server ... "); error = ipcfg_bind_dhcp_wait(ENET_DEVICE, FALSE, &ip_data); #else printf("Setting static IP address ... "); error = ipcfg_bind_staticip (ENET_DEVICE, &ip_data); #endif /* RTCS_DHCP */ if (error != IPCFG_ERROR_OK) { printf("\nRTCS failed to bind interface with IPv4, error = %X", error); _task_block(); } else { printf("OK\n"); } ipcfg_get_ip(ENET_DEVICE, &ip_data); printf("\nIP Address : %d.%d.%d.%d\n",IPBYTES(ip_data.ip)); printf("\nSubnet Address : %d.%d.%d.%d\n",IPBYTES(ip_data.mask)); printf("\nGateway Address : %d.%d.%d.%d\n",IPBYTES(ip_data.gateway)); printf("\nDNS Address : %d.%d.%d.%d\n",IPBYTES(ipcfg_get_dns_ip(ENET_DEVICE,0))); #endif /* BSP_ENET_DEVICE_COUNT > 0 */ #endif /* BSP_ENET_DEVICE_COUNT */ #if RTCS_PPP PPP_start(); #endif /* RTCS_PPP */ /* TODO: start server(s) in separate tasks */ }