/*----------------------------------------------------------------------------*/ int nxp_get_wait(ASerialPort_t* aPort, char* aBuff, int aSize, int aWait) { int count = 0; byte_t test; char *buff = malloc(aSize); while(!check_incoming(aPort)); while(count<aWait||check_incoming(aPort)) { while(!check_incoming(aPort)); test = get_byte_serial(aPort); #ifdef MY1DEBUG putchar(test); #endif if(count<aSize-1) buff[count] = test; count++; } if(count<aSize) buff[count] = 0x0; else buff[aSize-1] = 0x0; sscanf(buff,"%s",aBuff); #ifdef MY1DEBUG printf("BUFF:'%s', CHECK:%d/%d\n",aBuff,count,aWait); #endif free(buff); return count < aSize ? 0 : count; }
/*----------------------------------------------------------------------------*/ int bcheck_device(ASerialPort_t* aPort, ADeviceNXP_t* aDevice) { int test; printf("Device blank check... "); test = nxp_blank_check(aPort,aDevice); if(test) { printf("Cannot check device blank status!\n"); return ERROR_GENERAL; } if(!aDevice->do_acknowledge) { byte_t temp; int size = strlen(aDevice->hexstr); while(check_incoming(aPort)) { temp = get_byte_serial(aPort); if (size==COUNT_HEXSTR_BUFF-1) { aDevice->hexstr[size] = 0x0; continue; } aDevice->hexstr[size++] = temp; } aDevice->hexstr[size] = 0x0; printf(" [OK] Device NOT blank ('%s'){%d}!\n",aDevice->hexstr,size); return ERROR_GENERAL; } printf(" [OK] Device is blank!\n"); return test; }
static int mpoa_egress_cache_purge_reply( uint8_t * buff ){ int pos = 0; struct nhrp_fixed_h *fixed = (struct nhrp_fixed_h *)buff; struct nhrp_common_h *common; struct nhrp_cie *cie; struct extension_values values; struct k_message msg; memset(&values, 0, sizeof(struct extension_values)); memset(&msg,0,sizeof(struct k_message)); pos += sizeof(struct nhrp_fixed_h); common = (struct nhrp_common_h*)(buff + pos); if(!check_incoming(ntohl(common->request_ID), MPOA_EGRESS_CACHE_PURGE_REQUEST)) return -1; pos += sizeof(struct nhrp_common_h); cie = (struct nhrp_cie *)(buff + pos); msg.ip_mask = calculate_ip_mask(cie->prefix_length); if(fixed->ar_extoff) parse_extensions(buff + ntohs(fixed->ar_extoff),&values); else { printf("mpcd: p_recogn.c: warning: "); printf("no extensions in MPOA Egress Cache Purge Reply\n"); return -1; } if (values.dll_header_present == 0) { printf("mpcd: p_recogn.c: warning: "); printf("DLL Header Extension missing in MPOA Egress Cache Purge Reply\n"); return -1; } msg.content.eg_info.cache_id = values.dll_ext.cache_id; msg.type = EGRESS_PURGE_RCVD; memcpy(msg.MPS_ctrl,mpc_control.MPS_CTRL_ATM_ADDR,ATM_ESA_LEN); return send_to_kernel(&msg); }
/*----------------------------------------------------------------------------*/ int nxp_check_isp(ASerialPort_t* aPort, ADeviceNXP_t* aDevice) { my1key_t key; char nxp_sync_char = aDevice ? aDevice->sync_char : NXP_SYNC_CHAR; int status = NXP_CHECK_START; flush_serial(aPort); purge_serial(aPort); while(status<NXP_CHECK_FOUND) { put_byte_serial(aPort,nxp_sync_char); wait_outgoing(aPort); if(check_incoming(aPort)) { byte_t test = get_byte_serial(aPort); if(test==nxp_sync_char) { status = NXP_CHECK_FOUND; break; } } key = get_keyhit(); if(key==KEY_ESCAPE) status = NXP_CHECK_ABORT; else if(key==KEY_BSPACE) status = NXP_CHECK_RESET; } flush_serial(aPort); purge_serial(aPort); return status; }
/*----------------------------------------------------------------------------*/ int nxp_send_hex(ASerialPort_t* aPort, const char* hexstr) { byte_t test; int length = 0, error = 0, loop; while(hexstr[length]) length++; #ifdef MY1DEBUG printf("Length=%d, HexStr='%s'\n",length,hexstr); #endif purge_serial(aPort); for(loop=0;loop<length;loop++) { put_byte_serial(aPort, hexstr[loop]); while(!check_incoming(aPort)); test = get_byte_serial(aPort); if(test!=hexstr[loop]) { #ifdef MY1DEBUG printf("Error: '%c' <=> '%c'\n",test,hexstr[loop]); #endif error++; } } /* end with dos newline char pair */ put_byte_serial(aPort, 0x0d); /* cr */ put_byte_serial(aPort, 0x0a); /* lf */ return error; }
static void comm_call_slowfds(void) { while (n_slow_fds) { int i = (squid_random() % n_slow_fds) + 1; int fd = slow_fds[i]; fde *F = &fd_table[fd]; commRemoveSlow(fd); if (F->read_handler) { PF *hdl = F->read_handler; void *hdl_data = F->read_data; debug(5, 8) ("comm_call_handlers(): Calling read handler on fd=%d\n", fd); #if SIMPLE_COMM_HANDLER commUpdateReadHandler(fd, NULL, NULL); commResumeFD(fd); hdl(fd, hdl_data); #else /* Optimized version to avoid the fd bouncing in/out of the waited set */ F->read_handler = NULL; F->read_data = NULL; F->read_pending = COMM_PENDING_NORMAL; hdl(fd, hdl_data); /* backoff check is for delayed connections kicked alive from checkTimeouts */ if (F->flags.open && (!F->read_handler || F->flags.backoff)) { if (F->flags.backoff && commDeferRead(fd) != 1) F->flags.backoff = 0; commUpdateEvents(fd); } #endif statCounter.select_fds++; check_incoming(); } } }
static int mpoa_resolution_reply( uint8_t * buff ){ int pos = 0; struct k_message msg; struct extension_values values; struct nhrp_common_h *common; struct nhrp_cie *cie; struct nhrp_fixed_h *fixed = (struct nhrp_fixed_h*)buff; memset(&values, 0, sizeof(struct extension_values)); memset(&msg,0,sizeof(struct k_message)); pos += sizeof(struct nhrp_fixed_h); common = (struct nhrp_common_h*)(buff + pos); if(!check_incoming(ntohl(common->request_ID),MPOA_RESOLUTION_REQUEST)) return -1; pos += sizeof(struct nhrp_common_h); cie = (struct nhrp_cie*)(buff + pos); if(cie->code){ print_cie_code(cie->code); return -1; } msg.content.in_info.holding_time = ntohs(cie->holding_time); if(fixed->ar_extoff) pos += parse_extensions(buff + ntohs(fixed->ar_extoff), &values); if (values.egress_cache_tag_ext_present == 0) { printf("mpcd: p_recogn.c: warning: "); printf("received MPOA Resolution Reply "); printf("with no Egress Cache Tag Extension\n"); } if(values.tag_present && values.tag == 0) { printf("mpcd: p_recogn.c: warning: "); printf("received MPOA Resolution Reply "); printf("with Egress Cache Tag Extension where tag == 0\n"); values.tag_present = 0; } if(values.tag_present){ msg.content.in_info.tag = values.tag; } msg.type = MPOA_RES_REPLY_RCVD; msg.content.in_info.in_dst_ip = common->dst_protocol_address; memcpy(msg.content.in_info.eg_MPC_ATM_addr,cie->cli_nbma_address,ATM_ESA_LEN); memcpy(msg.MPS_ctrl,mpc_control.MPS_CTRL_ATM_ADDR, ATM_ESA_LEN); if(values.service_category_present) msg.qos.txtp.traffic_class = service_category_to_traff_class(values.service_category); else msg.qos.txtp.traffic_class = ATM_UBR; send_to_kernel(&msg); keep_alive_sm_running = 1; return MPOA_RESOLUTION_REPLY; }
// Main void main (void) { init(); // Initialize while (1) { check_incoming(); // Car enters check_outgoing(); // Car leaves /** * Create an artificial time delay * Needed so the user can have time to remove his/her finger * from the button before the BUTTON_ENTER == 1 is checked again **/ for (cycle_delay = 0; cycle_delay < cycle_duration; cycle_delay++); display(free_slots); // Output the number of free slots } }
/*----------------------------------------------------------------------------*/ int find_device(ASerialPort_t* aPort, ADeviceNXP_t* aDevice) { int test; char nxp_sync_char = aDevice ? aDevice->sync_char : NXP_SYNC_CHAR; aDevice->found = 0; /** try this once! */ put_byte_serial(aPort,nxp_sync_char); wait_outgoing(aPort); usleep(NXP_FIND_WAIT); if(check_incoming(aPort)) { byte_t test = get_byte_serial(aPort); if(test==nxp_sync_char) { aDevice->found = 1; return NXP_CHECK_FOUND; } } printf("\nReset the NXP device... "); test = nxp_check_isp(aPort,aDevice); if(test==NXP_CHECK_FOUND) { aDevice->found = 1; printf("NXP device found!\n\n"); } else if(test==NXP_CHECK_RESET) { aDevice->found = 0; printf("User Reset Request!\n\n"); } else /** if(test==NXP_CHECK_ABORT) */ { printf("User Abort Request!\n\n"); } return test; }
static void h_xstor(struct context *ctx, char *arg, int flags) { char *t; int f = -1; struct stat st; int stou = 0; char tbuf[PATH_MAX + 1]; DebugIn(DEBUG_COMMAND); if (ctx->transfer_in_progress) { reply(ctx, MSG_501_Transfer_in_progress); DebugOut(DEBUG_COMMAND); return; } ctx->outgoing_data = 0; if (ctx->dfn > -1 && io_get_cb_i(ctx->io, ctx->dfn) == (void *) accept_data) { io_set_i(ctx->io, ctx->dfn); io_clr_o(ctx->io, ctx->dfn); io_set_cb_e(ctx->io, ctx->dfn, (void *) cleanup_data); io_set_cb_h(ctx->io, ctx->dfn, (void *) cleanup_data); } quota_add(ctx, 0); if (ctx->quota_path && (ctx->quota_ondisk >= ctx->quota_limit)) { reply(ctx, MSG_451_quota_exceeded); logmsg("%s: quota limit reached", ctx->user); DebugOut(DEBUG_COMMAND); return; } if (!arg) { stou = -1; snprintf(tbuf, sizeof(tbuf), "%s/stou.XXXXXX", ctx->cwd); arg = tbuf; t = buildpath(ctx, arg); } else if (acl_binary_only(ctx, arg, (t = buildpath(ctx, arg)))) { reply(ctx, MSG_504_no_ascii); cleanup_data_reuse(ctx, ctx->dfn); DebugOut(DEBUG_COMMAND); return; } st.st_size = 0; if (t) acl_set_umask(ctx, arg, t); if (ctx->anonymous || stou) flags |= O_EXCL; if (t && (!ctx->anonymous || check_incoming(ctx, t, 077)) && !pickystat_path(ctx, &st, t) && (stat(t, &st), (f = myopen(t, O_RDWR | O_CREAT | O_LARGEFILE | O_NOFOLLOW | flags, ctx->chmod_filemask | (0644 & ~ctx->umask), stou)) > -1)) { fcntl(f, F_SETFD, FD_CLOEXEC); ctx->quota_filesize_before_stor = st.st_size; ctx->quota_update_on_close = 1; if (ctx->dfn < 0) connect_port(ctx); if (ctx->dfn < 0) { reply(ctx, MSG_431_Opening_datacon_failed); close(f); ctx->dbuf = buffer_free_all(ctx->dbuf); DebugOut(DEBUG_COMMAND); return; } ctx->ffn = f; if (strlen(t) >= sizeof(ctx->filename)) { logerr("buffer too small in %s:%d (%s/%s)", __FILE__, __LINE__, ctx->user, t); reply(ctx, MSG_551_Internal_error); close(f); cleanup(ctx, ctx->dfn); ctx->dbuf = buffer_free_all(ctx->dbuf); DebugOut(DEBUG_COMMAND); return; } strcpy(ctx->filename, t); ctx->filesize = 0; ctx->bytecount = 0; if (io_get_cb_i(ctx->io, ctx->dfn) == (void *) socket2buffer || is_connected(ctx->dfn)) { if (stou) replyf(ctx, "125 FILE: %s\r\n", ctx->filename + ctx->rootlen); else replyf(ctx, MSG_125_Starting_dc, ctx->use_ascii ? "ASCII" : "BINARY", ctx->use_tls_d ? "TLS " : ""); } else { if (stou) replyf(ctx, "150 FILE: %s\r\n", ctx->filename + ctx->rootlen); else replyf(ctx, MSG_150_Opening_dc, ctx->use_ascii ? "ASCII" : "BINARY", ctx->use_tls_d ? "TLS " : ""); } ctx->transfer_in_progress = 1; if (ctx->io_offset) { if (ctx->use_ascii) { ctx->offset = 0; ctx->remaining = st.st_size; io_sched_add(ctx->io, ctx, (void *) skipbytes, 0, 0); #ifdef WITH_MMAP if (use_mmap) ctx->iomode = IOMODE_mmap; else #endif ctx->iomode = IOMODE_read, ctx->iomode_fixed = 1; } else { lseek(f, ctx->io_offset, SEEK_SET); ctx->io_offset = 0; } } if (io_get_cb_i(ctx->io, ctx->dfn) == (void *) socket2buffer) { /* already connected */ io_clr_o(ctx->io, ctx->dfn); io_set_i(ctx->io, ctx->dfn); } ctx->transferstart = io_now.tv_sec; ctx->count_files++; } else { if (stou && errno == EEXIST) reply(ctx, MSG_451_unique_file_failure); else reply(ctx, MSG_550_Permission_denied); cleanup_data_reuse(ctx, ctx->dfn); } DebugOut(DEBUG_COMMAND); }
// Check UDP for incoming packets void check_incoming() { int packetSize; int i; int empty = 0; int found = -1; packetSize = udp.parsePacket(); if (packetSize) { IPAddress remote = udp.remoteIP(); // read the packet into packetBufffer udp.read(packetBuffer, UDP_TX_PACKET_MAX_SIZE); #ifdef DEBUG Serial.print("Received packet of size "); Serial.println(packetSize); Serial.print("From "); for (i = 0; i < 4; i++) { Serial.print(remote[i], DEC); if (i < 3) { Serial.print("."); } } Serial.print(", port "); Serial.println(udp.remotePort()); Serial.print("Dump: "); for (i = 0; i < packetSize / sizeof(uint16_t); i++) { Serial.print(*((uint16_t *) (packetBuffer + i * sizeof(uint16_t)))); Serial.print(" "); } Serial.println(); #endif // Master sends all packets to its clients and updates cache if (my_node_type == MSGMULTI_MASTER) { found = -1; empty = 0; send_packet(packetBuffer, packetSize, remote); for (i = 0; i < MSGMULTI_MAXCLIENTS; i++) { if (clients[i].client == remote) { found = i; break; } if (clients[i].expire <= 0) empty = i; } if (found >= 0) clients[found].expire = 1024; else { clients[empty].client = remote; clients[empty].expire = 1024; } } // Process incoming statuses for (i = 0; i < *((uint16_t *) packetBuffer); i++) { receive_status((struct msgrecord *) (packetBuffer + i * sizeof(struct msgrecord) + sizeof(uint16_t))); } // Repeat incoming check to process all packets in queue check_incoming(); } // Check if we have to repeat last sent statuses resend_status(); } // void check_incoming()
static inline void comm_call_handlers(int fd, int read_event, int write_event) { fde *F = &fd_table[fd]; const int do_incoming = read_event == 1 || write_event == 1; debug(5, 8) ("comm_call_handlers(): got fd=%d read_event=%x write_event=%x F->read_handler=%p F->write_handler=%p\n" ,fd, read_event, write_event, F->read_handler, F->write_handler); if (F->read_handler) { int do_read = 0; switch (F->read_pending) { case COMM_PENDING_NORMAL: case COMM_PENDING_WANTS_READ: do_read = read_event; break; case COMM_PENDING_WANTS_WRITE: do_read = write_event; break; case COMM_PENDING_NOW: do_read = 1; break; } if (do_read) { PF *hdl = F->read_handler; void *hdl_data = F->read_data; /* If the descriptor is meant to be deferred, don't handle */ switch (commDeferRead(fd)) { #if DELAY_POOLS case -1: commAddSlow(fd); break; #endif default: if (!(F->flags.backoff)) { debug(5, 1) ("comm_call_handlers(): WARNING defer handler for fd=%d (desc=%s) does not call commDeferFD() - backing off manually\n", fd, F->desc); commDeferFD(fd); } break; case 0: debug(5, 8) ("comm_call_handlers(): Calling read handler on fd=%d\n", fd); #if SIMPLE_COMM_HANDLER commUpdateReadHandler(fd, NULL, NULL); hdl(fd, hdl_data); #else /* Optimized version to avoid the fd bouncing in/out of the waited set */ F->read_handler = NULL; F->read_data = NULL; F->read_pending = COMM_PENDING_NORMAL; hdl(fd, hdl_data); if (F->flags.open && !F->read_handler) commUpdateEvents(fd); #endif statCounter.select_fds++; if (do_incoming) check_incoming(); break; } } } if (F->write_handler) { int do_write = 0; switch (F->write_pending) { case COMM_PENDING_WANTS_READ: do_write = read_event; break; case COMM_PENDING_NORMAL: case COMM_PENDING_WANTS_WRITE: do_write = write_event; break; case COMM_PENDING_NOW: do_write = 1; break; } if (do_write) { PF *hdl = F->write_handler; void *hdl_data = F->write_data; #if SIMPLE_COMM_HANDLER commUpdateWriteHandler(fd, NULL, NULL); hdl(fd, hdl_data); #else /* Optimized version to avoid the fd bouncing in/out of the waited set */ F->write_handler = NULL; F->write_data = NULL; F->write_pending = COMM_PENDING_NORMAL; hdl(fd, hdl_data); if (F->flags.open) commUpdateEvents(fd); #endif statCounter.select_fds++; if (do_incoming) check_incoming(); } } }