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);
}
