void *read_serial_packet(serial_source src, int *len) /* Effects: Read the serial source src. If a packet is available, return it. If in blocking mode and no packet is available, wait for one. Returns: the packet read (in newly allocated memory), with *len is set to the packet length, or NULL if no packet is yet available and the serial source is in non-blocking mode */ { read_and_process(src, TRUE); for (;;) { struct packet_list *entry; entry = pop_protocol_packet(src, P_PACKET_NO_ACK); if (entry) { uint8_t *packet = entry->packet; *len = entry->len; free(entry); return packet; } if (src->non_blocking && serial_source_empty(src)) return NULL; source_wait(src, NULL); read_and_process(src, src->non_blocking); } }
int write_serial_packet(serial_source src, const void *packet, int len) /* Effects: writes len byte packet to serial source src Returns: 0 if packet successfully written, 1 if successfully written but not acknowledged, -1 otherwise */ { struct timeval deadline; src->send.seqno++; if (write_framed_packet(src, P_PACKET_ACK, src->send.seqno, packet, len) < 0) return -1; gettimeofday(&deadline, NULL); add_timeval(&deadline, ACK_TIMEOUT); for (;;) { struct packet_list *entry; read_and_process(src); entry = pop_protocol_packet(src, P_ACK); if (entry) { uint8_t acked = entry->packet[0]; free(entry->packet); free(entry); if (acked == src->send.seqno) return 0; } else if (source_wait(src, &deadline) < 0) return 1; } }
int main(int argc, char* argv[]) { if (argc != 2){ printf("Usage: %s <rgb32 fits>\n",argv[0]); return -1; } return read_and_process(argv[1]); }
void YJDouyuBarrage::init_connection() { connect(ui.m_getBarrage_pushButton, SIGNAL(clicked()), this, SLOT(ok_button_clicked())); connect(ui.m_disconnect_pushButton, SIGNAL(clicked()), this, SLOT(disconnect_button_clicked())); connect(m_barrage_tcp_socket, SIGNAL(readyRead()), this, SLOT(read_and_process())); connect(m_keep_alive_timer, SIGNAL(timeout()), this, SLOT(run_keepAlive_thread())); //connect(m_barrage_tcp_socket, SIGNAL(error()), this, SLOT(handleTcpSocketError())); connect(m_barrage_tcp_socket, SIGNAL(connected()), this, SLOT(handleTcpSocketConnected())); connect(m_barrage_tcp_socket, SIGNAL(disconnected()), this, SLOT(handleTcpSocketDisconnected())); }
int main(int argc, char **argv) { int c; struct client *p, *nextp; extern void setup(), newconnection(), whatsup(struct client *p); while ((c = getopt(argc, argv, "p:")) != EOF) { if (c == 'p') { if ((port = atoi(optarg)) == 0) { fprintf(stderr, "%s: port number must be a positive integer\n", argv[0]); return(1); } } else { fprintf(stderr, "usage: %s [-p port]\n", argv[0]); return(1); } } setup(); /* aborts on error */ /* the only way the server exits is by being killed */ for (;;) { fd_set fdlist; int maxfd = listenfd; FD_ZERO(&fdlist); FD_SET(listenfd, &fdlist); for (p = top; p; p = p->next) { FD_SET(p->fd, &fdlist); if (p->fd > maxfd) maxfd = p->fd; } if (select(maxfd + 1, &fdlist, NULL, NULL, NULL) < 0) { perror("select"); } else { if (FD_ISSET(listenfd, &fdlist)) newconnection(); for (p = top; p; p = nextp) { nextp = p->next; /* in case we remove this client because of error */ if (FD_ISSET(p->fd, &fdlist)) read_and_process(p); } } } }
void diff_archive (void) { struct stat stat_data; int name_length; int status; errno = EPIPE; /* FIXME: errno should be read-only */ /* FIXME: remove perrors */ set_next_block_after (current_header); decode_header (current_header, ¤t_stat, ¤t_format, 1); /* Print the block from `current_header' and `current_stat'. */ if (verbose_option) { if (now_verifying) fprintf (stdlis, _("Verify ")); print_header (); } switch (current_header->header.typeflag) { default: WARN ((0, 0, _("Unknown file type '%c' for %s, diffed as normal file"), current_header->header.typeflag, current_file_name)); /* Fall through. */ case AREGTYPE: case REGTYPE: case GNUTYPE_SPARSE: case CONTTYPE: /* Appears to be a file. See if it's really a directory. */ name_length = strlen (current_file_name) - 1; if (current_file_name[name_length] == PATHSEP) goto really_dir; if (!get_stat_data (&stat_data)) { if (current_header->oldgnu_header.isextended) skip_extended_headers (); skip_file ((long) current_stat.st_size); goto quit; } if (!S_ISREG (stat_data.st_mode)) { report_difference (_("Not a regular file")); skip_file ((long) current_stat.st_size); goto quit; } stat_data.st_mode &= 07777; if (stat_data.st_mode != current_stat.st_mode) report_difference (_("Mode differs")); #if !MSDOS && !WIN32 /* stat() in djgpp's C library gives a constant number of 42 as the uid and gid of a file. So, comparing an FTP'ed archive just after unpack would fail on MSDOS. */ if (stat_data.st_uid != current_stat.st_uid) report_difference (_("Uid differs")); if (stat_data.st_gid != current_stat.st_gid) report_difference (_("Gid differs")); #endif if (stat_data.st_mtime != current_stat.st_mtime) report_difference (_("Mod time differs")); if (current_header->header.typeflag != GNUTYPE_SPARSE && stat_data.st_size != current_stat.st_size) { report_difference (_("Size differs")); skip_file ((long) current_stat.st_size); goto quit; } diff_handle = open (current_file_name, O_NDELAY | O_RDONLY | O_BINARY); if (diff_handle < 0 && !absolute_names_option) { char *tmpbuf = xmalloc (strlen (current_file_name) + 2); *tmpbuf = PATHSEP; strcpy (tmpbuf + 1, current_file_name); diff_handle = open (tmpbuf, O_NDELAY | O_RDONLY); free (tmpbuf); } if (diff_handle < 0) { ERROR ((0, errno, _("Cannot open %s"), current_file_name)); if (current_header->oldgnu_header.isextended) skip_extended_headers (); skip_file ((long) current_stat.st_size); report_difference (NULL); goto quit; } /* Need to treat sparse files completely differently here. */ if (current_header->header.typeflag == GNUTYPE_SPARSE) diff_sparse_files (current_stat.st_size); else { if (multi_volume_option) { assign_string (&save_name, current_file_name); save_totsize = current_stat.st_size; /* save_sizeleft is set in read_and_process. */ } read_and_process ((long) (current_stat.st_size), process_rawdata); if (multi_volume_option) assign_string (&save_name, NULL); } status = close (diff_handle); if (status < 0) ERROR ((0, errno, _("Error while closing %s"), current_file_name)); quit: break; #if !MSDOS case LNKTYPE: { dev_t dev; ino_t ino; if (!get_stat_data (&stat_data)) break; dev = stat_data.st_dev; ino = stat_data.st_ino; status = stat (current_link_name, &stat_data); if (status < 0) { if (errno == ENOENT) report_difference (_("Does not exist")); else { WARN ((0, errno, _("Cannot stat file %s"), current_file_name)); report_difference (NULL); } break; } if (stat_data.st_dev != dev || stat_data.st_ino != ino) { char *message = (char *) xmalloc (MESSAGE_BUFFER_SIZE + strlen (current_link_name)); sprintf (message, _("Not linked to %s"), current_link_name); report_difference (message); free (message); break; } break; } #endif /* not MSDOS */ #ifdef S_ISLNK case SYMTYPE: { char linkbuf[NAME_FIELD_SIZE + 3]; /* FIXME: may be too short. */ status = readlink (current_file_name, linkbuf, (sizeof linkbuf) - 1); if (status < 0) { if (errno == ENOENT) report_difference (_("No such file or directory")); else { WARN ((0, errno, _("Cannot read link %s"), current_file_name)); report_difference (NULL); } break; } linkbuf[status] = '\0'; /* null-terminate it */ if (strncmp (current_link_name, linkbuf, (size_t) status) != 0) report_difference (_("Symlink differs")); break; } #endif /* not S_ISLNK */ #ifdef S_IFCHR case CHRTYPE: current_stat.st_mode |= S_IFCHR; goto check_node; #endif /* not S_IFCHR */ #ifdef S_IFBLK /* If local system doesn't support block devices, use default case. */ case BLKTYPE: current_stat.st_mode |= S_IFBLK; goto check_node; #endif /* not S_IFBLK */ #ifdef S_ISFIFO /* If local system doesn't support FIFOs, use default case. */ case FIFOTYPE: # ifdef S_IFIFO current_stat.st_mode |= S_IFIFO; # endif current_stat.st_rdev = 0; /* FIXME: do we need this? */ goto check_node; #endif /* S_ISFIFO */ check_node: /* FIXME: deal with umask. */ if (!get_stat_data (&stat_data)) break; if (current_stat.st_rdev != stat_data.st_rdev) { report_difference (_("Device numbers changed")); break; } if ( #ifdef S_IFMT current_stat.st_mode != stat_data.st_mode #else /* POSIX lossage. */ (current_stat.st_mode & 07777) != (stat_data.st_mode & 07777) #endif ) { report_difference (_("Mode or device-type changed")); break; } break; case GNUTYPE_DUMPDIR: { char *dumpdir_buffer = get_directory_contents (current_file_name, 0); if (multi_volume_option) { assign_string (&save_name, current_file_name); save_totsize = current_stat.st_size; /* save_sizeleft is set in read_and_process. */ } if (dumpdir_buffer) { dumpdir_cursor = dumpdir_buffer; read_and_process ((long) (current_stat.st_size), process_dumpdir); free (dumpdir_buffer); } else read_and_process ((long) (current_stat.st_size), process_noop); if (multi_volume_option) assign_string (&save_name, NULL); /* Fall through. */ } case DIRTYPE: /* Check for trailing /. */ name_length = strlen (current_file_name) - 1; really_dir: while (name_length && current_file_name[name_length] == PATHSEP) current_file_name[name_length--] = '\0'; /* zap / */ if (!get_stat_data (&stat_data)) break; if (!S_ISDIR (stat_data.st_mode)) { report_difference (_("No longer a directory")); break; } if ((stat_data.st_mode & 07777) != (current_stat.st_mode & 07777)) report_difference (_("Mode differs")); break; case GNUTYPE_VOLHDR: break; case GNUTYPE_MULTIVOL: { off_t offset; name_length = strlen (current_file_name) - 1; if (current_file_name[name_length] == PATHSEP) goto really_dir; if (!get_stat_data (&stat_data)) break; if (!S_ISREG (stat_data.st_mode)) { report_difference (_("Not a regular file")); skip_file ((long) current_stat.st_size); break; } stat_data.st_mode &= 07777; offset = from_oct (1 + 12, current_header->oldgnu_header.offset); if (stat_data.st_size != current_stat.st_size + offset) { report_difference (_("Size differs")); skip_file ((long) current_stat.st_size); break; } diff_handle = open (current_file_name, O_NDELAY | O_RDONLY | O_BINARY); if (diff_handle < 0) { WARN ((0, errno, _("Cannot open file %s"), current_file_name)); report_difference (NULL); skip_file ((long) current_stat.st_size); break; } status = lseek (diff_handle, offset, 0); if (status != offset) { WARN ((0, errno, _("Cannot seek to %ld in file %s"), offset, current_file_name)); report_difference (NULL); break; } if (multi_volume_option) { assign_string (&save_name, current_file_name); save_totsize = stat_data.st_size; /* save_sizeleft is set in read_and_process. */ } read_and_process ((long) (current_stat.st_size), process_rawdata); if (multi_volume_option) assign_string (&save_name, NULL); status = close (diff_handle); if (status < 0) ERROR ((0, errno, _("Error while closing %s"), current_file_name)); break; } } }
int main(int argc, char* argv[]) { read_and_process(); return 0; }