ADCDevice::ADCDevice() :
BaseDevice()
{
this->connectionPoints = new list<ConnectionPoint*> ();
this->pinouts = new std::list<Pinout*>();
this->outPoint = new OutConnectionPoint( 2, "Output",
"ADC Device Output", FLOAT_TYPE, new float(0) );
this->outPoint->RegisterRefreshHandler( this );
this->connectionPoints->push_back( outPoint );
// ADC Pionout definition:
Command cmdInit( INIT_CMD );
Command cmdStop( STOP_CMD );
list<Command>* pinoutSupportedCommands = new list<Command>();
pinoutSupportedCommands->push_back( cmdInit );
pinoutSupportedCommands->push_back( cmdStop );
list<Event>* pinoutSupportedEvents = new list<Event>();
list<EventParameter>* eventParams = new list<EventParameter>();
eventParams->push_back( EventParameter( ADCDevice_VALUE, 0, INT_TYPE ) );
Event eventClick( ADCDevice_VALEVENT, eventParams );
pinoutSupportedEvents->push_back( eventClick );
Pinout* pinout = new Pinout( 0, "ADC Pinout", "ADC Device Pinout",
pinoutSupportedCommands, pinoutSupportedEvents );
pinout->PinoutEventTriggered = &PinoutEventTriggered;
this->pinouts->push_back( pinout );
this->currentPinoutValue = 0.0f;
this->SetName( ADCDevice_DEVNAME );
}
int main (void)
{
cpuInit();
uartInit(BAUDRATE);
#ifdef CLKOUT
IOCON_PIO0_1 &= ~(0x3f);
IOCON_PIO0_1 |= IOCON_PIO0_1_FUNC_CLKOUT;
SCB_CLKOUTCLKSEL |= 0x3; // select system osci
SCB_CLKOUTCLKUEN = SCB_CLKOUTCLKUEN_UPDATE;
SCB_CLKOUTCLKUEN = SCB_CLKOUTCLKUEN_DISABLE;
SCB_CLKOUTCLKUEN = SCB_CLKOUTCLKUEN_UPDATE;
while( !(SCB_CLKOUTCLKUEN & SCB_CLKOUTCLKUEN_UPDATE));
SCB_CLKOUTCLKDIV = SCB_CLKOUTCLKDIV_DIV1;
#endif
//initPWM(16, 0, (1<<0), 256, 0);
printf("Starting in main\n");
cmdInit();
while (1)
{
cmdPoll();
}
}
void cmdIndexed(u08 cmdInput)
{
switch (cpState)
{
case INDEX:
//
// Validate index parameter (0-9,a-z)
//
if (-1 == (input[INDEX] = charToNum(cmdInput)))
{
cmdInit();
return;
}
cpState = PARAM1;
break;
case PARAM1:
input[PARAM1] = cmdInput;
cpState = PARAM2;
break;
case PARAM2:
if (input[INDEX] > 1)
{
uart_send_buffered(input[COMMAND]);
uart_send_buffered(numToChar(input[INDEX] - 2));
uart_send_buffered(input[PARAM1]);
uart_send_buffered(cmdInput);
}
else
{
switch (input[COMMAND])
{
case CMD_PIXEL_ON:
case CMD_PIXEL_OFF:
dm_pixel(input[INDEX],
(input[COMMAND] == CMD_PIXEL_ON ? 1 : 0),
input[PARAM1] - '0',
cmdInput - '0');
break;
}
}
cmdInit();
break;
}
}
void cmdSetBits(u08 cmdInput)
{
char length;
if (LENGTH == cpState)
{
//
// Validate length parameter (0-9,a-z)
//
if (-1 == (length = charToNum(cmdInput)))
{
cmdInit();
return;
}
//
// if length > 2 then subtract 2 and pass this command on to the
// next controller in the chain
//
input[REMAINING] = length * 5;
length -= 2;
if (length > 0)
{
uart_send_buffered(input[COMMAND]);
uart_send_buffered(numToChar(length));
}
input[INDEX] = 0;
cpState = PARAM1;
return;
}
if (input[INDEX] < 10)
{
dm_progColumn(input[INDEX] / 5, input[INDEX] % 5, cmdInput);
}
else
{
uart_send_buffered(cmdInput);
}
input[INDEX]++;
input[REMAINING]--;
if (0 == input[REMAINING])
{
cmdInit();
}
}
void init_cmdline_interface(){
cmdInit(115200);
cmdAdd("help", help);
cmdAdd("h", help);
cmdAdd("?", help);
cmdAdd("", Nop);
cmdAdd("hello", hello);
cmdAdd("BackToNoHost", BackToNoHost_cmd);
cmdAdd("InitDevInfo", InitDevInfo_cmd);
cmdAdd("SEState", SE_state_cmd);
cmdAdd("BindReg", BindReg_cmd);
cmdAdd("BindLogin", BindLogin_cmd);
cmdAdd("BindLogout", BindLogout_cmd);
cmdAdd("BackToNoHost", BackToNoHost_cmd);
cmdAdd("BackToInit",BackToInit_cmd);
cmdAdd("InitWallet", InitWallet_cmd);
cmdAdd("PINAuth", PIN_Auth_cmd);
cmdAdd("QueryWalletInfo", hdw_query_wallet_info_cmd);
cmdAdd("QueryAllAccount", hdw_query_all_account_info_cmd);
cmdAdd("QueryAccountKey", hdw_query_account_key_info_cmd);
cmdAdd("CreateAccount", hdw_create_account_cmd);
cmdAdd("QueryAccountInfo", hdw_query_account_info_cmd);
cmdAdd("CreateNextAddr", hdw_generate_next_trx_addr_cmd);
//cmdAdd("SetSecurityPolicy", SetSecurityPolicy_cmd);
cmdAdd("Transaction", Transaction_cmd);
cmdAdd("Voltage", ReadVoltage_cmd);
cmdAdd("ReinitBLE", ReinitBLE_cmd);
cmdAdd("AddVcard", AddVcard_cmd);
cmdAdd("ResetHitconTokenDisplay", ResetHitconTokenDisplay);
Serial.println("**************************************************************************");
for (int i = 0; i < 10; ++i)
{
Serial.print("*");Serial.print(HitconBanner[i]);Serial.println("*");
}
Serial.println("**************************************************************************");
Serial.println("Hitcon Badge 2018 Cmdline interface\r\nVersion:1.0.12\r\nenter help to see the cmd list");
cmd_display();
}
int main(int _argc, char** _argv)
{
//DBG(BX_COMPILER_NAME " / " BX_CPU_NAME " / " BX_ARCH_NAME " / " BX_PLATFORM_NAME);
#if BX_CONFIG_CRT_FILE_READER_WRITER
s_fileReader = new bx::CrtFileReader;
s_fileWriter = new bx::CrtFileWriter;
#endif // BX_CONFIG_CRT_FILE_READER_WRITER
cmdInit();
cmdAdd("mouselock", cmdMouseLock);
cmdAdd("graphics", cmdGraphics );
cmdAdd("exit", cmdExit );
inputInit();
inputAddBindings("bindings", s_bindings);
entry::WindowHandle defaultWindow = { 0 };
entry::setWindowTitle(defaultWindow, bx::baseName(_argv[0]));
int32_t result = ::_main_(_argc, _argv);
inputRemoveBindings("bindings");
inputShutdown();
cmdShutdown();
#if BX_CONFIG_CRT_FILE_READER_WRITER
delete s_fileReader;
s_fileReader = NULL;
delete s_fileWriter;
s_fileWriter = NULL;
#endif // BX_CONFIG_CRT_FILE_READER_WRITER
return result;
}
void
main(int argc, char* argv[])
{
char **cmd, *p;
int i, ncmd, tflag;
fmtinstall('D', dirfmt);
fmtinstall('F', fcallfmt);
fmtinstall('M', dirmodefmt);
quotefmtinstall();
/*
* Insulate from the invoker's environment.
*/
if(rfork(RFREND|RFNOTEG|RFNAMEG) < 0)
sysfatal("rfork: %r");
close(0);
open("/dev/null", OREAD);
close(1);
open("/dev/null", OWRITE);
cmd = nil;
ncmd = tflag = 0;
vtAttach();
ARGBEGIN{
case '?':
default:
usage();
break;
case 'c':
p = EARGF(usage());
currfsysname = p;
cmd = vtMemRealloc(cmd, (ncmd+1)*sizeof(char*));
cmd[ncmd++] = p;
break;
case 'D':
Dflag ^= 1;
break;
case 'f':
p = EARGF(usage());
currfsysname = foptname = p;
readCmdPart(p, &cmd, &ncmd);
break;
case 'm':
mempcnt = atoi(EARGF(usage()));
if(mempcnt <= 0 || mempcnt >= 100)
usage();
break;
case 't':
tflag = 1;
break;
}ARGEND
if(argc != 0)
usage();
consInit();
cliInit();
msgInit();
conInit();
cmdInit();
fsysInit();
exclInit();
fidInit();
srvInit();
lstnInit();
usersInit();
for(i = 0; i < ncmd; i++)
if(cliExec(cmd[i]) == 0)
fprint(2, "%s: %R\n", cmd[i]);
vtMemFree(cmd);
if(tflag && consTTY() == 0)
consPrint("%s\n", vtGetError());
vtDetach();
exits(0);
}
/*
* Main entry point.
*/
void main(void)
{
static TICK8 t = 0;
#ifdef HEATHERD
NODE_INFO tcpServerNode;
static TCP_SOCKET tcpSocketUser = INVALID_SOCKET;
BYTE c;
#endif
static BYTE testLED;
testLED = 1;
//Set SWDTEN bit, this will enable the watch dog timer
WDTCON_SWDTEN = 1;
aliveCntrMain = 0xff; //Disable alive counter during initialization. Setting to 0xff disables it.
//Initialize any application specific hardware.
InitializeBoard();
//Initialize all stack related components. Following steps must
//be performed for all applications using PICmicro TCP/IP Stack.
TickInit();
//Initialize buses
busInit();
//Initialize serial ports early, because they could be required for debugging
if (appcfgGetc(APPCFG_USART1_CFG & APPCFG_USART_ENABLE)) {
appcfgUSART(); //Configure the USART1
}
if (appcfgGetc(APPCFG_USART2_CFG & APPCFG_USART_ENABLE)) {
appcfgUSART2(); //Configure the USART2
}
//After initializing all modules that use interrupts, enable global interrupts
INTCON_GIEH = 1;
INTCON_GIEL = 1;
//Initialize file system.
fsysInit();
//Intialize HTTP Execution unit
htpexecInit();
//Initialize Stack and application related NV variables.
appcfgInit();
//First call appcfgCpuIOValues() and then only appcfgCpuIO()!!! This ensures the value are set, before enabling ports.
appcfgCpuIOValues(); //Configure the CPU's I/O port pin default values
appcfgCpuIO(); //Configure the CPU's I/O port pin directions - input or output
appcfgADC(); //Configure ADC unit
appcfgPWM(); //Configure PWM Channels
//Serial configuration menu - display it for configured time and allow user to enter configuration menu
scfInit(appcfgGetc(APPCFG_STARTUP_SER_DLY));
//LCD Display Initialize
lcdInit();
//Initialize expansion board
appcfgXboard();
StackInit();
#if defined(STACK_USE_HTTP_SERVER)
HTTPInit();
#endif
#if defined(STACK_USE_FTP_SERVER)
FTPInit();
#endif
//Intialise network componet of buses - only call after StackInit()!
busNetInit();
//Initializes events.
evtInit();
//Initializes "UDP Command Port" and "UDP Even Port".
cmdInit();
ioInit();
#if (DEBUG_MAIN >= LOG_DEBUG)
debugPutMsg(1); //@mxd:1:Starting main loop
#endif
/*
* Once all items are initialized, go into infinite loop and let
* stack items execute their tasks.
* If application needs to perform its own task, it should be
* done at the end of while loop.
* Note that this is a "co-operative mult-tasking" mechanism
* where every task performs its tasks (whether all in one shot
* or part of it) and returns so that other tasks can do their
* job.
* If a task needs very long time to do its job, it must broken
* down into smaller pieces so that other tasks can have CPU time.
*/
#ifdef HEATHERD
//Create a TCP socket that listens on port 54123
tcpSocketUser = TCPListen(HEATHERD);
#define HEATHERD_ENABLE (!(appcfgGetc(APPCFG_TRISA) & 1))
#define HEATHERD_WRITE_ENABLE (!(appcfgGetc(APPCFG_TRISA) & 2))
#endif
while(1)
{
aliveCntrMain = 38; //Reset if not services in 52.42ms x 38 = 2 seconds
//Blink SYSTEM LED every second.
if (appcfgGetc(APPCFG_SYSFLAGS) & APPCFG_SYSFLAGS_BLINKB6) {
//Configure RB6 as output, and blink it every 500ms
if ( TickGetDiff8bit(t) >= ((TICK8)TICKS_PER_SECOND / (TICK8)2) )
{
t = TickGet8bit();
//If B6 is configured as input, change to output
if (appcfgGetc(APPCFG_TRISB) & 0x40) {
appcfgPutc(APPCFG_TRISB, appcfgGetc(APPCFG_TRISB) & 0b10111111);
}
TRISB_RB6 = 0;
LATB6 ^= 1; //Toggle
//Toggle IOR5E LED, if IOR5E is present
if (appcfgGetc(APPCFG_XBRD_TYPE) == XBRD_TYPE_IOR5E) {
ior5eLatchData.bits.ledPWR ^= 1; // Toggle
}
}
}
//This task performs normal stack task including checking for incoming packet,
//type of packet and calling appropriate stack entity to process it.
StackTask();
//Service LCD display
lcdService();
//Process commands
cmdTask();
//Process events
evtTask();
//Process serial busses
busTask();
//I2C Task
i2cTask();
#ifdef HEATHERD
//Has a remote node made connection with the port we are listening on
if ((tcpSocketUser != INVALID_SOCKET) && TCPIsConnected(tcpSocketUser)) {
if (HEATHERD_ENABLE) {
//Is there any data waiting for us on the TCP socket?
//Because of the design of the Modtronix TCP/IP stack we have to
//consume all data sent to us as soon as we detect it.
while(TCPIsGetReady(tcpSocketUser)) {
//We are only interrested in the first byte of the message.
TCPGet(tcpSocketUser, &c);
if (HEATHERD_WRITE_ENABLE) serPutByte(c);
}
//Discard the socket buffer.
TCPDiscard(tcpSocketUser);
while (serIsGetReady() && TCPIsPutReady(tcpSocketUser)) {
TCPPut(tcpSocketUser,serGetByte());
}
TCPFlush(tcpSocketUser);
} else {
TCPDisconnect(tcpSocketUser);
}
}
#endif
#if defined(STACK_USE_HTTP_SERVER)
//This is a TCP application. It listens to TCP port 80
//with one or more sockets and responds to remote requests.
HTTPServer();
#endif
#if defined(STACK_USE_FTP_SERVER)
FTPServer();
#endif
#if defined(STACK_USE_ANNOUNCE)
DiscoveryTask();
#endif
#if defined(STACK_USE_NBNS)
NBNSTask();
#endif
//Add your application speicifc tasks here.
ProcessIO();
//For DHCP information, display how many times we have renewed the IP
//configuration since last reset.
if ( DHCPBindCount != myDHCPBindCount )
{
#if (DEBUG_MAIN >= LOG_INFO)
debugPutMsg(2); //@mxd:2:DHCP Bind Count = %D
debugPutByteHex(DHCPBindCount);
#endif
//Display new IP address
#if (DEBUG_MAIN >= LOG_INFO)
debugPutMsg(3); //@mxd:3:DHCP complete, IP = %D.%D.%D.%D
debugPutByteHex(AppConfig.MyIPAddr.v[0]);
debugPutByteHex(AppConfig.MyIPAddr.v[1]);
debugPutByteHex(AppConfig.MyIPAddr.v[2]);
debugPutByteHex(AppConfig.MyIPAddr.v[3]);
#endif
myDHCPBindCount = DHCPBindCount;
#if defined(STACK_USE_ANNOUNCE)
AnnounceIP();
#endif
}
}
}
int main(int _argc, char** _argv)
{
//DBG(BX_COMPILER_NAME " / " BX_CPU_NAME " / " BX_ARCH_NAME " / " BX_PLATFORM_NAME);
if (BX_ENABLED(ENTRY_CONFIG_PROFILER) )
{
rmtSettings* settings = rmt_Settings();
BX_WARN(NULL != settings, "Remotery is not enabled.");
if (NULL != settings)
{
settings->malloc = rmtMalloc;
settings->realloc = rmtRealloc;
settings->free = rmtFree;
rmtError err = rmt_CreateGlobalInstance(&s_rmt);
BX_WARN(RMT_ERROR_NONE != err, "Remotery failed to create global instance.");
if (RMT_ERROR_NONE == err)
{
rmt_SetCurrentThreadName("Main");
}
else
{
s_rmt = NULL;
}
}
}
#if BX_CONFIG_CRT_FILE_READER_WRITER
s_fileReader = new bx::CrtFileReader;
s_fileWriter = new bx::CrtFileWriter;
#endif // BX_CONFIG_CRT_FILE_READER_WRITER
cmdInit();
cmdAdd("mouselock", cmdMouseLock);
cmdAdd("graphics", cmdGraphics );
cmdAdd("exit", cmdExit );
inputInit();
inputAddBindings("bindings", s_bindings);
entry::WindowHandle defaultWindow = { 0 };
entry::setWindowTitle(defaultWindow, bx::baseName(_argv[0]) );
setWindowSize(defaultWindow, ENTRY_DEFAULT_WIDTH, ENTRY_DEFAULT_HEIGHT);
int32_t result = ::_main_(_argc, _argv);
inputRemoveBindings("bindings");
inputShutdown();
cmdShutdown();
#if BX_CONFIG_CRT_FILE_READER_WRITER
delete s_fileReader;
s_fileReader = NULL;
delete s_fileWriter;
s_fileWriter = NULL;
#endif // BX_CONFIG_CRT_FILE_READER_WRITER
if (BX_ENABLED(ENTRY_CONFIG_PROFILER)
&& NULL != s_rmt)
{
rmt_DestroyGlobalInstance(s_rmt);
}
return result;
}
void cmdCountedLength(u08 cmdInput)
{
char length;
char indexOffset;
//
// If we're expecting the length parameter...
//
if (LENGTH == cpState)
{
//
// Validate length parameter (0-9,a-z)
//
// switch (input[COMMAND])
// {
// case CMD_SET_TEXT:
length = cmdInput;
// break;
//
// default:
// if (-1 == (length = charToNum(cmdInput)))
// {
// cmdInit();
// return;
// }
// break;
// }
//
// if length > 2 then subtract 2 and pass this command on to the
// next controller in the chain
//
input[REMAINING] = length;
length -= 2;
if (length > 0)
{
uart_send_buffered(input[COMMAND]);
//uart_send_buffered(numToChar(length));
uart_send_buffered(length);
}
input[INDEX] = 0;
cpState = PARAM1;
return;
}
//
// We are accepting parameters, maybe for us, maybe to be passed along
//
if (0 == input[INDEX] || 1 == input[INDEX])
{
switch (input[COMMAND])
{
case CMD_SET_TEXT:
dm_setChar(input[INDEX], cmdInput);
break;
case CMD_SET_PALETTE:
dm_setPalette(input[INDEX], cmdInput - '0');
break;
case CMD_SHIFT_LEFT:
case CMD_SHIFT_RIGHT:
case CMD_SHIFT_DOWN:
case CMD_SHIFT_UP:
dm_shift(input[INDEX], input[COMMAND], cmdInput - '0');
break;
case CMD_ROLL_LEFT:
case CMD_ROLL_RIGHT:
case CMD_ROLL_DOWN:
case CMD_ROLL_UP:
dm_roll(input[INDEX], input[COMMAND], cmdInput - '0');
break;
case CMD_RESET_TRANSFORMS:
dm_reset(input[INDEX]);
break;
case CMD_CUSTOM_CHARACTER:
dm_displayProgrammed(input[INDEX], cmdInput - '0');
break;
case CMD_COPY_CUSTOM:
dm_copyToCustom(input[INDEX], cmdInput);
break;
case CMD_FLIP:
dm_setFlip(input[INDEX], cmdInput - '0');
break;
case CMD_INVERT:
dm_setReverse(input[INDEX], cmdInput - '0');
break;
case CMD_MIRROR:
dm_setMirror(input[INDEX], cmdInput - '0');
break;
}
}
else
{
uart_send_buffered(cmdInput);
}
input[INDEX]++;
input[REMAINING]--;
if (0 == input[REMAINING])
{
cmdInit();
}
}
void systemInit()
{
cpuInit();
systickInit((CFG_CPU_CCLK / 1000) * CFG_SYSTICK_DELAY_IN_MS);
gpioInit();
pmuInit();
adcInit(); // Init adc pins to avoid wasting 60uA in deep sleep
#ifdef CFG_PRINTF_UART
// Initialise UART with the default baud rate (set in projectconfig.h)
uartInit(CFG_UART_BAUDRATE);
#endif
// Switch to 3.3V if TPS780 (etc.) is being used
#if defined CFG_VREG_ALT_PRESENT && CFG_VREG_ALT_PRESENT == 1
gpioSetDir(CFG_VREG_ALT_PORT, CFG_VREG_ALT_PIN, gpioDirection_Output);
gpioSetValue(CFG_VREG_ALT_PORT, CFG_VREG_ALT_PIN, 0);
gpioSetPullup(&CFG_VREG_ALT_REG32, gpioPullupMode_Inactive);
#endif
// Set LED pin as output and turn LED off
gpioSetDir(CFG_LED_PORT, CFG_LED_PIN, 1);
gpioSetValue(CFG_LED_PORT, CFG_LED_PIN, CFG_LED_OFF);
// Initialise the ST7565 128x64 pixel display
#ifdef CFG_ST7565
st7565Init();
st7565ClearScreen(); // Clear the screen
st7565Backlight(1); // Enable the backlight
#endif
// Initialise the SSD1306 OLED display
#ifdef CFG_SSD1306
ssd1306Init(SSD1306_SWITCHCAPVCC);
ssd1306ClearScreen(); // Clear the screen
#endif
// Initialise EEPROM
#ifdef CFG_I2CEEPROM
mcp24aaInit();
#endif
// Initialise Chibi
#ifdef CFG_CHIBI
// Write addresses to EEPROM for the first time if necessary
// uint16_t addr_short = 0x1166;
// uint64_t addr_ieee = addr_short;
// mcp24aaWriteBuffer(CFG_CHIBI_EEPROM_SHORTADDR, (uint8_t *)&addr_short, 2);
// mcp24aaWriteBuffer(CFG_CHIBI_EEPROM_IEEEADDR, (uint8_t *)&addr_ieee, 8);
chb_init();
#endif
// Setup SD Card
#ifdef CFG_SDCARD
// Turn off SD card by default (saves power)
gpioSetDir(CFG_SDCARD_ENPORT, CFG_SDCARD_ENPIN, gpioDirection_Output); /* Set enable pin to output */
gpioSetValue(CFG_SDCARD_ENPORT, CFG_SDCARD_ENPIN, 0); /* Disable card by setting ENPIN low */
gpioSetPullup(&CFG_SDCARD_ENREG32, gpioPullupMode_Inactive);
#endif
#ifdef CFG_LM75B
// Initialise LM75B
lm75bInit();
// Read temp once to make sure we are in sleep mode
int32_t temp;
lm75bGetTemperature(&temp);
#endif
#ifdef CFG_BAT
// Turn off battery voltage divider by default
gpioSetDir(CFG_BAT_ENPORT, CFG_BAT_ENPIN, gpioDirection_Output ); // Set voltage divider enable pin to output
gpioSetValue(CFG_BAT_ENPORT, CFG_BAT_ENPIN, 0 ); // Disable the voltage divider by default
gpioSetPullup(&CFG_BAT_ENREG32, gpioPullupMode_Inactive);
#endif
// Start the command line interface (if requested)
#ifdef CFG_INTERFACE
printf("%sType '?' for a list of available commands%s", CFG_PRINTF_NEWLINE, CFG_PRINTF_NEWLINE);
cmdInit();
#endif
}
/* main():
* The equivalent of the MONCMD server built into uMon...
* Blocks on port 777 waiting for an incoming message, then
* responds with "thanks".
*/
int
main(int argc, char *argv[])
{
int rc = 0;
unetStart();
cmdInit();
mon_printf("%s: MONCMD server using uMon's ethernet API...\n",
argv[0]);
/* This loop processes incoming UDP and incoming serial port
* (console) activity... Terminate on reception of ctrl-c
* (0x03) from console.
*/
while(1) {
if (mon_gotachar()) {
int c = mon_getchar();
if (c == 0x03) {
mon_printf("\n<ctrl-c>\n");
break;
}
else
processChar(c);
}
/* Set up the server to receive packets on any port...
* Then after udpRecvFrom returns, use the value of u.dport
* to determine which port the packet came in on.
*/
udpInfo.dport = ANY_UDP_PORT;
udpInfo.packet = (char *)unetPacket;
udpInfo.plen = sizeof(unetPacket);
/* Check for an incoming packet. This does not block. It will
* return negative if there is an error, zero of there is no packet
* pending; else some positive number representing the incoming
* packet size.
*/
rc = udpRecvFrom(&udpInfo);
if (rc > 0) {
if (udpInfo.dport == 777) {
udp_umoncmd((char *)udpInfo.udata);
}
else {
mon_printf("\nUDP rcv'd on port %d, from %d.%d.%d.%d:%d ...\n",
udpInfo.dport,
IP1(udpInfo.sip.s_addr), IP2(udpInfo.sip.s_addr),
IP3(udpInfo.sip.s_addr), IP4(udpInfo.sip.s_addr),
udpInfo.sport);
mon_printmem((char *)udpInfo.udata,rc,1);
}
}
else if (rc < 0) {
unetError("recv",rc,UNETACT_ALL);
}
}
unetStop();
return(0);
}
