static void rfcomm_connect_cb(GIOChannel *chan, GError *conn_err, gpointer user_data) { struct serial_port *port = user_data; struct serial_device *device = port->device; struct rfcomm_dev_req req; int sk, fd; DBusMessage *reply; /* Owner exited? */ if (!port->listener_id) return; if (conn_err) { error("%s", conn_err->message); reply = failed(port->msg, conn_err->message); goto fail; } memset(&req, 0, sizeof(req)); req.dev_id = -1; req.flags = (1 << RFCOMM_REUSE_DLC); bacpy(&req.src, &device->src); bacpy(&req.dst, &device->dst); req.channel = port->channel; g_io_channel_unref(port->io); port->io = NULL; sk = g_io_channel_unix_get_fd(chan); port->id = ioctl(sk, RFCOMMCREATEDEV, &req); if (port->id < 0) { int err = errno; error("ioctl(RFCOMMCREATEDEV): %s (%d)", strerror(err), err); reply = failed(port->msg, strerror(err)); g_io_channel_shutdown(chan, TRUE, NULL); goto fail; } port->dev = g_strdup_printf("/dev/rfcomm%d", port->id); debug("Serial port %s created", port->dev); g_io_channel_shutdown(chan, TRUE, NULL); /* Addressing connect port */ fd = port_open(port); if (fd < 0) /* Open in progress: Wait the callback */ return; open_notify(fd, 0, port); return; fail: g_dbus_send_message(device->conn, reply); g_dbus_remove_watch(device->conn, port->listener_id); port->listener_id = 0; }
/* * Opens the input data-feed. Given a feedname (path in the file system), * determine what type of input feed it is. Attempt to open * the feed. Hook up the appropriate read_, _stats, and (optional) _close * function pointers. Return errno on failure else set *fdp to the descriptor * and return 0. * * @param feedfname [in] The name of the input data-feed * @param fdp [out] The file-descriptor of the input data-feed * @param maxProdSize [in] The size, in bytes, of the largest expected * data-product * Returns (if INPUT_IS_SOCKET): * ENOENT gethostbyname() failure. * EAFNOSUPPORT AF_INET address-family not supported. * EMFILE No more file descriptors available for this process. * ENFILE No more file descriptors available for the system. * EACCES The process does not have appropriate privileges. * ENOBUFS Insufficient resources were available in the system to * perform the operation. * ENOMEM Insufficient memory was available to fulfill the request. * ENOSR There were insufficient STREAMS resources available for the * operation to complete. * EADDRNOTAVAIL The specified address is not available from the local * machine. * ECONNREFUSED The target address was not listening for connections or * refused the connection request. * EINTR The attempt to establish a connection was interrupted by * delivery of a signal that was caught; the connection will be * established asynchronously. * ENETUNREACH No route to the network is present. * EPROTOTYPE The specified address has a different type than the socket * bound to the specified peer address. * ETIMEDOUT The attempt to connect timed out before a connection was * made. * ECONNRESET Remote host reset the connection request. * EHOSTUNREACH The destination host cannot be reached (probably because the * host is down or a remote router cannot reach it). * ENETDOWN The local interface used to reach the destination is down. */ int open_feed(const char *feedfname, int *const fdp, const unsigned long maxProdSize) { extern char *rawfname; /* declared in main() module */ int status = ENOERR; #if NET if(INPUT_IS_SOCKET) { status = port_open(feedfname, (unsigned short) server_port, fdp); if(status != ENOERR) return status; if((status = initTheXbuf(read_file, maxProdSize)) != ENOERR) return status; feed_stats = file_stats; feed_close = file_close; } else /* dangling else */ #endif /* NET */ switch( which(feedfname) ) { #ifdef TTY case TTY : if((status = tty_open(feedfname, fdp)) != ENOERR) return status; if((status = initTheXbuf(read_tty, maxProdSize)) != ENOERR) return status; feed_stats = tty_stats; feed_close = tty_close; break; #endif /* TTY */ default : /* just treat it like a file */ if(*feedfname == '-' && feedfname[1] == 0) { /* use stdin */ *fdp = fileno(stdin); unotice("FILE stdin"); } else { if((status = file_open(feedfname, fdp)) != ENOERR) return status; } if((status = initTheXbuf(read_file, maxProdSize)) != ENOERR) return status; feed_stats = file_stats; feed_close = file_close; break; } if(rawfname != NULL) { (void) open_rawfile( rawfname ); } return status; }
void main() { int x; initsystem(); port_open(BAUD); for(;;) { costate { x=wfd login(); if(x<0) abort; } } }
void rfid::onControlRFtransmit_clicked() { port_open(); tag.control_rf_transmit(true); if(!tag.packet_received[4]==0x00) { ui->label_scanStatus->setText("RF Transmit successfull"); qDebug()<<" control tranmit error!! try again"; } else { qDebug()<<"control RF transmit true set!!"; ui->pushButton_selectMifare->setEnabled(true); ui->label_scanStatus->setText("RF Transmit successfull"); } }
void motors_init(void) { // Original (IdMind) // char init1[] = "di\rencres 2064\ransw 0\rapl 0\rsor 0\rsp 30000\rlcc 5000\rlpc 8000\rac 30000\rpor16\rI30\rcontmod\rv0\r"; //char init2[] = "diprog\rprogseq\rseta1\ra1\rdelay80\rjpe2\rseta1\rdi\rjmp1\ra2\rdajnz3\ren\rseta2\rjmp1\ra3\rseta2\rjmp1\rend\renprog\r"; // Modified (yoda) char init1[1024]; char init2[] = "diprog\rprogseq\rseta1\ra1\rdelay25\rjpe2\rseta1\rdi\rjmp1\ra2\rdajnz3\ren\rseta2\rjmp1\ra3\rseta2\rjmp1\rend\renprog\r"; sprintf(init1, "di\rencres 2064\ransw 0\rapl 0\rsor 0\rsp 30000\rlcc 5000\rlpc 8000\rac %d\rpor16\rI30\rcontmod\rv0\reepsav\r", accel); // p[0].name = "/dev/ttyS0"; // p[1].name = "/dev/ttyS1"; for (int i=0 ; i<NP ; i++) { port_open(i); port_send(i, init1); port_send(i, init2); // BUG: port_send(i, "AC15\r"); } send_state(true); }
int main( ) { port_open(); im_start( ); char crrnt_frame[16]; while ( 1 ) { usleep( 1000000 / 30 ); double *array = im_getSnapshot( IM_FFT ); int i; for ( i = 0; i*16 < 256; i++) { crrnt_frame[i] = (19.0*array[i*16]); printf( " %i", crrnt_frame[i]); } printf( "\n" ); fflush( stdout ); } im_stop( ); return 0; }
int main( int argc, const char* argv[] ) { const char* host; struct sockaddr_in si_me; struct hostent *addr; int port; uint32_t server_ip; time_t lasttime, t; fd_set fds; int i, maxfd, res; struct timeval timeout; TReader *reader; if( argc < 2 ) { fprintf (stderr, "usage: %s hostname [port]\n", argv[0]); return 1; } /* reset variables */ g_duplicate_pos = 0; g_reader_sequence = 0; memset(&g_duplicate_backlog, 0, sizeof(g_duplicate_backlog)); /* initialize descriptor list */ FD_ZERO(&fds); memset(&g_reader, 0, sizeof(g_reader)); g_reader[0].id = 1; g_reader[0].fd = port_open("/dev/ttyO1"); g_reader[1].id = 2; g_reader[1].fd = port_open("/dev/ttyO2"); maxfd = g_reader[1].fd+1; /* assign default port if needed */ port = ( argc < 3 ) ? PORT : atoi(argv[2]); /* get host name */ host = argv[1]; if ((g_socket = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) { fprintf(stderr, "error: can't create socket\n"); return 2; } else { memset ((char *) &si_me, 0, sizeof (si_me)); si_me.sin_family = AF_INET; si_me.sin_port = htons (port); si_me.sin_addr.s_addr = htonl (INADDR_ANY); if (bind (g_socket, (sockaddr *) & si_me, sizeof (si_me)) == -1) { fprintf (stderr, "error: can't bind to listening socket\n"); return 3; } lasttime = 0; server_ip = 0; memset (&g_si_server, 0, sizeof (g_si_server)); g_si_server.sin_family = AF_INET; g_si_server.sin_port = htons (port); /* loop over UART data */ while (1) { /* update server connection */ t = time (NULL); if ((t - lasttime) > REFRESH_SERVER_IP_TIME) { if ((addr = gethostbyname (host)) == NULL) fprintf (stderr, "error: can't resolve server name (%s)\n", host); else if ((addr->h_addrtype != AF_INET) || (addr->h_length != IP4_SIZE)) fprintf (stderr, "error: wrong address type\n"); else { memcpy (&g_si_server.sin_addr, addr->h_addr, addr->h_length); if (server_ip != g_si_server.sin_addr.s_addr) { server_ip = g_si_server.sin_addr.s_addr; fprintf (stderr, "refreshed server IP to [%s]\n", inet_ntoa (g_si_server.sin_addr)); } lasttime = t; } } /* set timeout value within input loop */ timeout.tv_usec = 0; /* milliseconds */ timeout.tv_sec = 1; /* seconds */ /* register descriptors */ for(i=0; i<MAX_UARTS; i++) FD_SET(g_reader[i].fd, &fds); /* wait for data */ res = select(maxfd, &fds, NULL, NULL, &timeout); /* retry on timeout */ if(res == 0) continue; /* process data for all readers */ for(i=0; i<MAX_UARTS; i++) { reader = &g_reader[i]; if(FD_ISSET(reader->fd, &fds)) do { res = read(reader->fd, buffer, BUFLEN); if(res>0) port_reader(reader, buffer, res); } while (res == BUFLEN); } } } }
int main(int argc, char* argv[]) { struct port_interface *port = NULL; int ret = 1; stm32_err_t s_err; parser_err_t perr; FILE *diag = stdout; fprintf(diag, "stm32flash " VERSION "\n\n"); fprintf(diag, "http://github.com/rogerclarkmelbourne/arduino_stm32\n\n"); if (parse_options(argc, argv) != 0) goto close; if (rd && filename[0] == '-') { diag = stderr; } if (wr) { /* first try hex */ if (!force_binary) { parser = &PARSER_HEX; p_st = parser->init(); if (!p_st) { fprintf(stderr, "%s Parser failed to initialize\n", parser->name); goto close; } } if (force_binary || (perr = parser->open(p_st, filename, 0)) != PARSER_ERR_OK) { if (force_binary || perr == PARSER_ERR_INVALID_FILE) { if (!force_binary) { parser->close(p_st); p_st = NULL; } /* now try binary */ parser = &PARSER_BINARY; p_st = parser->init(); if (!p_st) { fprintf(stderr, "%s Parser failed to initialize\n", parser->name); goto close; } perr = parser->open(p_st, filename, 0); } /* if still have an error, fail */ if (perr != PARSER_ERR_OK) { fprintf(stderr, "%s ERROR: %s\n", parser->name, parser_errstr(perr)); if (perr == PARSER_ERR_SYSTEM) perror(filename); goto close; } } fprintf(diag, "Using Parser : %s\n", parser->name); } else { parser = &PARSER_BINARY; p_st = parser->init(); if (!p_st) { fprintf(stderr, "%s Parser failed to initialize\n", parser->name); goto close; } } if (port_open(&port_opts, &port) != PORT_ERR_OK) { fprintf(stderr, "Failed to open port: %s\n", port_opts.device); goto close; } fprintf(diag, "Interface %s: %s\n", port->name, port->get_cfg_str(port)); if (init_flag && init_bl_entry(port, gpio_seq) == 0) goto close; stm = stm32_init(port, init_flag); if (!stm) goto close; fprintf(diag, "Version : 0x%02x\n", stm->bl_version); if (port->flags & PORT_GVR_ETX) { fprintf(diag, "Option 1 : 0x%02x\n", stm->option1); fprintf(diag, "Option 2 : 0x%02x\n", stm->option2); } fprintf(diag, "Device ID : 0x%04x (%s)\n", stm->pid, stm->dev->name); fprintf(diag, "- RAM : %dKiB (%db reserved by bootloader)\n", (stm->dev->ram_end - 0x20000000) / 1024, stm->dev->ram_start - 0x20000000); fprintf(diag, "- Flash : %dKiB (sector size: %dx%d)\n", (stm->dev->fl_end - stm->dev->fl_start ) / 1024, stm->dev->fl_pps, stm->dev->fl_ps); fprintf(diag, "- Option RAM : %db\n", stm->dev->opt_end - stm->dev->opt_start + 1); fprintf(diag, "- System RAM : %dKiB\n", (stm->dev->mem_end - stm->dev->mem_start) / 1024); uint8_t buffer[256]; uint32_t addr, start, end; unsigned int len; int failed = 0; int first_page, num_pages; /* * Cleanup addresses: * * Starting from options * start_addr, readwrite_len, spage, npages * and using device memory size, compute * start, end, first_page, num_pages */ if (start_addr || readwrite_len) { start = start_addr; if (is_addr_in_flash(start)) end = stm->dev->fl_end; else { no_erase = 1; if (is_addr_in_ram(start)) end = stm->dev->ram_end; else end = start + sizeof(uint32_t); } if (readwrite_len && (end > start + readwrite_len)) end = start + readwrite_len; first_page = flash_addr_to_page_floor(start); if (!first_page && end == stm->dev->fl_end) num_pages = 0xff; /* mass erase */ else num_pages = flash_addr_to_page_ceil(end) - first_page; } else if (!spage && !npages) { start = stm->dev->fl_start; end = stm->dev->fl_end; first_page = 0; num_pages = 0xff; /* mass erase */ } else { first_page = spage; start = flash_page_to_addr(first_page); if (start > stm->dev->fl_end) { fprintf(stderr, "Address range exceeds flash size.\n"); goto close; } if (npages) { num_pages = npages; end = flash_page_to_addr(first_page + num_pages); if (end > stm->dev->fl_end) end = stm->dev->fl_end; } else { end = stm->dev->fl_end; num_pages = flash_addr_to_page_ceil(end) - first_page; } if (!first_page && end == stm->dev->fl_end) num_pages = 0xff; /* mass erase */ } if (rd) { unsigned int max_len = port_opts.rx_frame_max; fprintf(diag, "Memory read\n"); perr = parser->open(p_st, filename, 1); if (perr != PARSER_ERR_OK) { fprintf(stderr, "%s ERROR: %s\n", parser->name, parser_errstr(perr)); if (perr == PARSER_ERR_SYSTEM) perror(filename); goto close; } fflush(diag); addr = start; while (addr < end) { uint32_t left = end - addr; len = max_len > left ? left : max_len; s_err = stm32_read_memory(stm, addr, buffer, len); if (s_err != STM32_ERR_OK) { fprintf(stderr, "Failed to read memory at address 0x%08x, target write-protected?\n", addr); goto close; } if (parser->write(p_st, buffer, len) != PARSER_ERR_OK) { fprintf(stderr, "Failed to write data to file\n"); goto close; } addr += len; fprintf(diag, "\rRead address 0x%08x (%.2f%%) ", addr, (100.0f / (float)(end - start)) * (float)(addr - start) ); fflush(diag); } fprintf(diag, "Done.\n"); ret = 0; goto close; } else if (rp) { fprintf(stdout, "Read-Protecting flash\n"); /* the device automatically performs a reset after the sending the ACK */ reset_flag = 0; stm32_readprot_memory(stm); fprintf(stdout, "Done.\n"); } else if (ur) { fprintf(stdout, "Read-UnProtecting flash\n"); /* the device automatically performs a reset after the sending the ACK */ reset_flag = 0; stm32_runprot_memory(stm); fprintf(stdout, "Done.\n"); } else if (eraseOnly) { ret = 0; fprintf(stdout, "Erasing flash\n"); if (num_pages != 0xff && (start != flash_page_to_addr(first_page) || end != flash_page_to_addr(first_page + num_pages))) { fprintf(stderr, "Specified start & length are invalid (must be page aligned)\n"); ret = 1; goto close; } s_err = stm32_erase_memory(stm, first_page, num_pages); if (s_err != STM32_ERR_OK) { fprintf(stderr, "Failed to erase memory\n"); ret = 1; goto close; } } else if (wu) { fprintf(diag, "Write-unprotecting flash\n"); /* the device automatically performs a reset after the sending the ACK */ reset_flag = 0; stm32_wunprot_memory(stm); fprintf(diag, "Done.\n"); } else if (wr) { fprintf(diag, "Write to memory\n"); off_t offset = 0; ssize_t r; unsigned int size; unsigned int max_wlen, max_rlen; max_wlen = port_opts.tx_frame_max - 2; /* skip len and crc */ max_wlen &= ~3; /* 32 bit aligned */ max_rlen = port_opts.rx_frame_max; max_rlen = max_rlen < max_wlen ? max_rlen : max_wlen; /* Assume data from stdin is whole device */ if (filename[0] == '-' && filename[1] == '\0') size = end - start; else size = parser->size(p_st); // TODO: It is possible to write to non-page boundaries, by reading out flash // from partial pages and combining with the input data // if ((start % stm->dev->fl_ps) != 0 || (end % stm->dev->fl_ps) != 0) { // fprintf(stderr, "Specified start & length are invalid (must be page aligned)\n"); // goto close; // } // TODO: If writes are not page aligned, we should probably read out existing flash // contents first, so it can be preserved and combined with new data if (!no_erase && num_pages) { fprintf(diag, "Erasing memory\n"); s_err = stm32_erase_memory(stm, first_page, num_pages); if (s_err != STM32_ERR_OK) { fprintf(stderr, "Failed to erase memory\n"); goto close; } } fflush(diag); addr = start; while (addr < end && offset < size) { uint32_t left = end - addr; len = max_wlen > left ? left : max_wlen; len = len > size - offset ? size - offset : len; if (parser->read(p_st, buffer, &len) != PARSER_ERR_OK) goto close; if (len == 0) { if (filename[0] == '-') { break; } else { fprintf(stderr, "Failed to read input file\n"); goto close; } } again: s_err = stm32_write_memory(stm, addr, buffer, len); if (s_err != STM32_ERR_OK) { fprintf(stderr, "Failed to write memory at address 0x%08x\n", addr); goto close; } if (verify) { uint8_t compare[len]; unsigned int offset, rlen; offset = 0; while (offset < len) { rlen = len - offset; rlen = rlen < max_rlen ? rlen : max_rlen; s_err = stm32_read_memory(stm, addr + offset, compare + offset, rlen); if (s_err != STM32_ERR_OK) { fprintf(stderr, "Failed to read memory at address 0x%08x\n", addr + offset); goto close; } offset += rlen; } for (r = 0; r < len; ++r) if (buffer[r] != compare[r]) { if (failed == retry) { fprintf(stderr, "Failed to verify at address 0x%08x, expected 0x%02x and found 0x%02x\n", (uint32_t)(addr + r), buffer [r], compare[r] ); goto close; } ++failed; goto again; } failed = 0; } addr += len; offset += len; fprintf(diag, "\rWrote %saddress 0x%08x (%.2f%%) ", verify ? "and verified " : "", addr, (100.0f / size) * offset ); fflush(diag); } fprintf(diag, "Done.\n"); ret = 0; goto close; } else if (crc) { uint32_t crc_val = 0; fprintf(diag, "CRC computation\n"); s_err = stm32_crc_wrapper(stm, start, end - start, &crc_val); if (s_err != STM32_ERR_OK) { fprintf(stderr, "Failed to read CRC\n"); goto close; } fprintf(diag, "CRC(0x%08x-0x%08x) = 0x%08x\n", start, end, crc_val); ret = 0; goto close; } else ret = 0; close: if (stm && exec_flag && ret == 0) { if (execute == 0) execute = stm->dev->fl_start; fprintf(diag, "\nStarting execution at address 0x%08x... ", execute); fflush(diag); if (stm32_go(stm, execute) == STM32_ERR_OK) { reset_flag = 0; fprintf(diag, "done.\n"); } else fprintf(diag, "failed.\n"); } if (stm && reset_flag) { fprintf(diag, "\nResetting device... "); fflush(diag); if (init_bl_exit(stm, port, gpio_seq)) fprintf(diag, "done.\n"); else fprintf(diag, "failed.\n"); } if (p_st ) parser->close(p_st); if (stm ) stm32_close (stm); if (port) port->close(port); fprintf(diag, "\n"); return ret; }
int main( int argc, const char* argv[] ) { int prev; uint8_t *p, data, buffer[64]; int fd, res, i; size_t len; TBeaconBuffer rx; /* configure default AES key */ aes_init(); if( argc < 2 ) { fprintf (stderr, "usage: %s /dev/tty.usbserial-AK0535TL\n", argv[0]); return 1; } /* initialize descriptor list */ fd = port_open(argv[1]); printf("fd=%i\n", fd); /* loop over UART data */ len = prev = 0; p = (uint8_t*)℞ while (1) { res = read(fd, buffer, sizeof(buffer)); for(i=0; i<res; i++) { data = buffer[i]; if(data==0xFF) prev = 1; else { if(!prev) { if(len<sizeof(rx)) *p++ = data; len++; } else { prev = 0; if(!data) { if(len<sizeof(rx)) *p++ = 0xFF; len++; } else { if(data!=0x01) fprintf(stderr, "error: invalid state 0x%02X\n", data); else { if(len==sizeof(rx)) port_rx(&rx.pkt, rx.rssi); else fprintf(stderr, "error: invalid RX lenght (%i)\n", (int)len); } p = (uint8_t*)℞ len = 0; } } } } } }
static void do_report() { union { void *ptr; ip_report_t *r; } r_u; struct in_addr ia; fifo_order(rfifo, &compare_ip_report_port, 1); /* JZ */ fifo_order(rfifo, &compare_ip_report_addr, 1); /* JZ */ while ((r_u.ptr=fifo_pop(rfifo)) != NULL) { char *extra=NULL; push_report_modules((const void *)r_u.ptr); /* ADD to it */ push_output_modules((const void *)r_u.ptr); /* display it somehow */ extra=get_report_extra(r_u.r); if (port_open(r_u.r->proto, r_u.r->type, r_u.r->subtype)) { ia.s_addr=r_u.r->host_addr; if (extra != NULL) { MSG(M_OUT, "Open \t%16s[%5d]\t\tFrom %s\tttl %d %s", getservname(r_u.r->sport), r_u.r->sport, inet_ntoa(ia), r_u.r->ttl, extra); } else { MSG(M_OUT, "Open \t%16s[%5d]\t\tFrom %s\tttl %d", getservname(r_u.r->sport), r_u.r->sport, inet_ntoa(ia), r_u.r->ttl); } } else if (port_closed(r_u.r->proto, r_u.r->type, r_u.r->subtype)) { struct in_addr ia2; char tmp[32]; memset(&ia2, 0, sizeof(ia2)); ia2.s_addr=r_u.r->trace_addr; ia.s_addr=r_u.r->host_addr; snprintf(tmp, sizeof(tmp) -1, "%s", inet_ntoa(ia)); if (r_u.r->trace_addr != r_u.r->host_addr) { /* treason uncloaked */ if (extra != NULL) { MSG(M_OUT, "Closed \t%16s[%5d]\t\tTo %s\tttl %d From %s %s", getservname(r_u.r->sport), r_u.r->sport, tmp, r_u.r->ttl, inet_ntoa(ia2), extra); } else { MSG(M_OUT, "Closed \t%16s[%5d]\t\tTo %s\tttl %d From %s", getservname(r_u.r->sport), r_u.r->sport, tmp, r_u.r->ttl, inet_ntoa(ia2)); } } else { if (extra != NULL) { MSG(M_OUT, "Closed \t%16s[%5d]\t\tFrom %s\tttl %d %s", getservname(r_u.r->sport), r_u.r->sport, tmp, r_u.r->ttl, extra); } else { MSG(M_OUT, "Closed \t%16s[%5d]\t\tFrom %s\tttl %d", getservname(r_u.r->sport), r_u.r->sport, tmp, r_u.r->ttl); } } } /* end PORT CLOSED */ else { struct in_addr ia2; char tmp[32]; memset(&ia2, 0, sizeof(ia2)); ia2.s_addr=r_u.r->trace_addr; ia.s_addr=r_u.r->host_addr; snprintf(tmp, sizeof(tmp) -1, "%s", inet_ntoa(ia)); if (r_u.r->trace_addr != r_u.r->host_addr) { /* treason uncloaked */ if (r_u.r->proto == IPPROTO_ICMP) { if (extra != NULL) { MSG(M_OUT, "T%.02dC%.02d \t%16s[%5d]\t\tTo %s\tttl %d From %s %s", r_u.r->type, r_u.r->subtype, getservname(r_u.r->sport), r_u.r->sport, tmp, r_u.r->ttl, inet_ntoa(ia2), extra); } else { MSG(M_OUT, "T%.02dC%.02d \t%16s[%5d]\t\tTo %s\tttl %d From %s", r_u.r->type, r_u.r->subtype, getservname(r_u.r->sport), r_u.r->sport, tmp, r_u.r->ttl, inet_ntoa(ia2)); } } else if (r_u.r->proto == IPPROTO_TCP) { char tcpflags[16]; str_tcpflags(tcpflags, r_u.r->type); if (extra != NULL) { MSG(M_OUT, "TCP%s\t%16s[%5d]\t\tTo %s\tttl %d From %s %s", tcpflags, getservname(r_u.r->sport), r_u.r->sport, tmp, r_u.r->ttl, inet_ntoa(ia2), extra); } else { MSG(M_OUT, "TCP%s\t%16s[%5d]\t\tTo %s\tttl %d From %s", tcpflags, getservname(r_u.r->sport), r_u.r->sport, tmp, r_u.r->ttl, inet_ntoa(ia2)); } } else if (r_u.r->proto == IPPROTO_UDP) { PANIC("now this is silly [1]"); } else { PANIC("now this is silly [2]"); } } else { if (r_u.r->proto == IPPROTO_ICMP) { if (extra != NULL) { MSG(M_OUT, "T%.02dC%.02d \t%16s[%5d]\t\tTo %s\tttl %d %s", r_u.r->type, r_u.r->subtype, getservname(r_u.r->sport), r_u.r->sport, tmp, r_u.r->ttl, extra); } else { MSG(M_OUT, "T%.02dC%.02d \t%16s[%5d]\t\tTo %s\tttl %d", r_u.r->type, r_u.r->subtype, getservname(r_u.r->sport), r_u.r->sport, tmp, r_u.r->ttl); } } else if (r_u.r->proto == IPPROTO_TCP) { char tcpflags[16]; str_tcpflags(tcpflags, r_u.r->type); if (extra != NULL) { MSG(M_OUT, "TCP%s\t%16s[%5d]\t\tTo %s\tttl %d %s", tcpflags, getservname(r_u.r->sport), r_u.r->sport, tmp, r_u.r->ttl, extra); } else { MSG(M_OUT, "TCP%s\t%16s[%5d]\t\tTo %s\tttl %d", tcpflags, getservname(r_u.r->sport), r_u.r->sport, tmp, r_u.r->ttl); } } else if (r_u.r->proto == IPPROTO_UDP) { PANIC("now this is silly [3]"); } else { PANIC("now this is silly [4]"); } } } /* end Not port OPEN or CLOSED */ fifo_destroy(r_u.r->od_q); xfree(r_u.ptr); } fifo_destroy(rfifo); return; }
static void handle_ipoutput(void *msg) { union { void *ptr; ip_report_t *r; uint8_t *d; } r_u, r_um; struct in_addr ia; uint16_t pk_len; assert(msg != NULL); r_um.ptr=msg; if (s->verbose > 5) MSG(M_DBG2, "Report has a %d byte packet attached to it", r_um.r->doff); assert(r_um.r->doff < s->vi->mtu); if (r_um.r->doff) { pk_len=r_um.r->doff; r_u.ptr=xmalloc(sizeof(ip_report_t) + pk_len + sizeof(pk_len)); memcpy(r_u.ptr, (const void *)r_um.ptr, sizeof(ip_report_t) + pk_len + sizeof(pk_len)); } else { r_u.ptr=xmalloc(sizeof(ip_report_t)); memcpy(r_u.ptr, (const void *)r_um.ptr, sizeof(ip_report_t)); } if (r_u.r->proto == IPPROTO_TCP && GET_DOCONNECT()) { do_connect(r_u.r); } if (port_open(r_u.r->proto, r_u.r->type, r_u.r->subtype)) { ia.s_addr=r_u.r->host_addr; if (fifo_find(rfifo, (const void *)r_u.ptr, &compare_ip_report) == NULL) { r_u.r->od_q=fifo_init(); fifo_push(rfifo, r_u.ptr); if (GET_NOPATIENCE()) { MSG(M_INFO, "Added %s port %d ttl %d", inet_ntoa(ia), r_u.r->sport, r_u.r->ttl); } } else { if (s->verbose > 4) MSG(M_DBG2, "DUP port open on %s:%d", inet_ntoa(ia), r_u.r->sport); xfree(r_u.ptr); } } else if (port_closed(r_u.r->proto, r_u.r->type, r_u.r->subtype) && GET_SHOWERRORS()) { char tmp[32]; ia.s_addr=r_u.r->host_addr; snprintf(tmp, sizeof(tmp) -1, "%s", inet_ntoa(ia)); if (fifo_find(rfifo, (const void *)r_u.ptr, &compare_ip_report) == NULL) { r_u.r->od_q=fifo_init(); fifo_push(rfifo, r_u.ptr); if (r_u.r->trace_addr != r_u.r->host_addr && GET_NOPATIENCE()) { struct in_addr ia2; /* treason uncloaked */ ia2.s_addr=r_u.r->trace_addr; MSG(M_OUT, "Closed %s port %d ttl %d From %s", tmp, r_u.r->sport, r_u.r->ttl, inet_ntoa(ia2)); } else if (GET_NOPATIENCE()) { MSG(M_OUT, "Closed %s port %d ttl %d", tmp, r_u.r->sport, r_u.r->ttl); } } else { if (s->verbose > 4) MSG(M_DBG2, "Dup close on %s:%d", inet_ntoa(ia), r_u.r->sport); xfree(r_u.ptr); } } /* end PORT CLOSED */ else if (GET_SHOWERRORS()) { struct in_addr ia2; char tmp[32]; ia2.s_addr=r_u.r->trace_addr; ia.s_addr=r_u.r->host_addr; snprintf(tmp, sizeof(tmp) -1, "%s", inet_ntoa(ia)); if (fifo_find(rfifo, (const void *)r_u.ptr, &compare_ip_report) == NULL) { r_u.r->od_q=fifo_init(); fifo_push(rfifo, r_u.ptr); if (r_u.r->trace_addr != r_u.r->host_addr && GET_NOPATIENCE()) { /* treason uncloaked */ if (r_u.r->proto == IPPROTO_ICMP) { MSG(M_OUT, "T%.02dC%.02d %s port %d ttl %d From %s", r_u.r->type, r_u.r->subtype, tmp, r_u.r->sport, r_u.r->ttl, inet_ntoa(ia2)); } else if (r_u.r->proto == IPPROTO_TCP) { char tcpflags[16]; str_tcpflags(tcpflags, r_u.r->type); MSG(M_OUT, "TCP%s %s port %d ttl %d From %s", tcpflags, tmp, r_u.r->sport, r_u.r->ttl, inet_ntoa(ia2)); } else if (r_u.r->proto == IPPROTO_UDP) { MSG(M_ERR, "<gh0st> \"Upgrade\" from Unix to Windows, eh? You keep using that word. I do not think it means what you think it means."); PANIC("now this is silly [-1]"); } else { PANIC("now this is silly [0]"); } } else { if (r_u.r->proto == IPPROTO_ICMP) { MSG(M_OUT, "T%.02dC%.02d %s port %d ttl %d", r_u.r->type, r_u.r->subtype, tmp, r_u.r->sport, r_u.r->ttl); } else if (r_u.r->proto == IPPROTO_TCP) { char tcpflags[16]; str_tcpflags(tcpflags, r_u.r->type); MSG(M_OUT, "TCP%s %s port %d ttl %d", tcpflags, tmp, r_u.r->sport, r_u.r->ttl); } else if (r_u.r->proto == IPPROTO_UDP) { PANIC("YOU SHOULDNT BE HERE, WHAT ARE YOU DOING HERE?!?!? DONT YOU UNDERSTAND WHAT THIS MEANS?!?!?!"); } else { PANIC("the sky is falling, the sky is falling, and dont call me shirley"); } } } else { if (s->verbose > 4) MSG(M_DBG2, "Dup ? on %s:%d", inet_ntoa(ia), r_u.r->sport); xfree(r_u.ptr); } } /* end Not port OPEN or CLOSED */ return; }
int main(int argc, char *argv[]) { struct termios ter, oldter; int portfd, status; portfd = port_open("/dev/ttyS0"); if(portfd < 0) { exit(EXIT_FAILURE); } /* Save current port settings for restore it later. */ tcgetattr(portfd, &oldter); /* Avoid all bits in new structure. */ memset(&ter, 0, sizeof(ter)); port_init(portfd, &ter); /* Set high level signal on DTR line. */ ioctl(portfd, TIOCMGET, &status); status |= TIOCM_DTR; status |= TIOCM_RTS; ioctl(portfd, TIOCMSET, &status); /* Flush input/output buffers of the port. */ tcflush(portfd, TCIOFLUSH); /* Interactive I/O loop. */ while("All humans alive") { char buf[256]; int buflen; printf("for quit, type 'q'(for help, type '?') " "else send string to port:\n"); printf("> "); fgets(buf, 256, stdin); buflen = strlen(buf); /* Skip newline character. */ buf[buflen - 1] = '\0'; if(!strcmp(buf, "q")) { break; } else if(!strcmp(buf, "?")) { printf("some help.\n"); } else { if(port_write(portfd, buf, buflen) < 0) { printf("Some error occured when send data to device.\n"); } else { usleep(500000); buflen = port_read(portfd, buf, 256); if(buflen < 0) { printf("Some error occered when read data from device.\n"); } printf("Read %d bytes: %s\n", buflen, buf); } } } exit: /* Restore old port settings. */ tcsetattr(portfd, TCSANOW, &oldter); status &= ~TIOCM_DTR; status &= ~TIOCM_RTS; ioctl(portfd, TIOCMSET, &status); /* Close port. */ port_close(portfd); return 0; }
//смена текущего com-порта на новый, зашифрованный в строке в виде "COM##" либо "NONE" bool rs232_port::connect_to_modem(const QString & s, int baud_rate, PORT_PROTOCOL_T prot) { return port_open(s,(QSerialPort::BaudRate)baud_rate,prot); }