自学教程：C++ update_events函数代码示例

void handle_pcap_read_result(mspool *ms, msevent *nse, enum nse_status status) {  msiod *iod = nse->iod;  mspcap *mp = (mspcap *)iod->pcap;  if (status == NSE_STATUS_TIMEOUT) {    nse->status = NSE_STATUS_TIMEOUT;    nse->event_done = 1;  } else if (status == NSE_STATUS_CANCELLED) {    nse->status = NSE_STATUS_CANCELLED;    nse->event_done = 1;  } else if (status == NSE_STATUS_SUCCESS) {    /* check if we already have something read */    if (FILESPACE_LENGTH(&(nse->iobuf)) == 0) {      nse->status = NSE_STATUS_TIMEOUT;      nse->event_done = 0;    } else {      nse->status = NSE_STATUS_SUCCESS; /* we have full buffer */      nse->event_done = 1;    }  } else {    assert(0); /* Currently we only know about TIMEOUT, CANCELLED, and SUCCESS callbacks */  }  /* If there are no more read events, we are done reading on the socket so we   * can take it off the descriptor list... */  if (nse->event_done && mp->pcap_desc >= 0) {    int ev;    ev = socket_count_readpcap_dec(iod);    update_events(iod, ms, EV_NONE, ev);  }}

// three_hz_loop - 3.3hz loopvoid Sub::three_hz_loop(){    set_leak_status(leak_detector.update());    failsafe_internal_pressure_check();    failsafe_internal_temperature_check();    // check if we've lost contact with the ground station    failsafe_gcs_check();    // check if we've lost terrain data    failsafe_terrain_check();#if AC_FENCE == ENABLED    // check if we have breached a fence    fence_check();#endif // AC_FENCE_ENABLED    update_events();#if CH6_TUNE_ENABLED == ENABLED    // update ch6 in flight tuning    tuning();#endif}

static voidhtsp_channelAddUpdate(htsp_connection_t *hc, htsmsg_t *m, int create){  uint32_t id, next;  int chnum;  char txt[200];  const char *title, *icon;  htsp_channel_t *ch;  if(htsmsg_get_u32(m, "channelId", &id))    return;  title = htsmsg_get_str(m, "channelName");  icon  = htsmsg_get_str(m, "channelIcon");  chnum = htsmsg_get_s32_or_default(m, "channelNumber", -1);  snprintf(txt, sizeof(txt), "%d", id);  hts_mutex_lock(&hc->hc_meta_mutex);  if(create) {    ch = htsp_channel_get(hc, id, 1);    if(prop_set_parent(ch->ch_root, hc->hc_channels_nodes))      abort();  } else {    ch = htsp_channel_get(hc, id, 0);    if(ch == NULL) {      TRACE(TRACE_ERROR, "HTSP", "Got update for unknown channel %d", id);      hts_mutex_unlock(&hc->hc_meta_mutex);      return;    }  }  hts_mutex_unlock(&hc->hc_meta_mutex);  if(icon != NULL)    prop_set_string(ch->ch_prop_icon, icon);  if(title != NULL) {    mystrset(&ch->ch_title, title);    prop_set_string(ch->ch_prop_title, title);  }  if(chnum != -1)    prop_set_int(ch->ch_prop_channelNumber, chnum);  if(htsmsg_get_u32(m, "eventId", &id))    id = 0;  if(htsmsg_get_u32(m, "nextEventId", &next))    next = 0;  update_events(hc, ch->ch_prop_events, id, next);}

bool AP_ServoRelayEvents::do_repeat_relay(uint8_t relay_num, int16_t _repeat, uint32_t _delay_ms){    if (!relay.enabled(relay_num)) {        return false;    }    type = EVENT_TYPE_RELAY;    channel = relay_num;    start_time_ms  = 0;    delay_ms        = _delay_ms/2; // half cycle time    repeat          = _repeat*2;  // number of full cycles    update_events();    return true;}

static void client_io(evutil_socket_t fd, short events, void *private_data){        struct client *client = private_data;        struct server *server;        int revents = 0;        if (events & EV_READ) {                revents |= POLLIN;        }        if (events & EV_WRITE) {                revents |= POLLOUT;        }        if (rpc_service(client->rpc, revents) < 0) {                fprintf(stderr, "rpc_service failed/n");                exit(10);        }        update_events(client->rpc, client->read_event, client->write_event);        if (client->is_finished) {                /*                 * Stop listening for new connections.                 */                event_free(client->listen_event);                client->listen_event = NULL;                /*                 * Stop listening for events on the client context.                 */                event_free(client->read_event);                client->read_event = NULL;                event_free(client->write_event);                client->write_event = NULL;                /*                 * Stop listening to server connections.                 */                for (server = server_list; server; server = server->next) {                        if (server->read_event) {                                event_free(server->read_event);                                server->read_event = NULL;                        }                        if (server->write_event) {                                event_free(server->write_event);                                server->write_event = NULL;                        }                }        }}

static void save_settings(struct trace_capture *cap, const char *filename){	struct shark_info *info = cap->info;	struct tracecmd_xml_handle *handle;	const char *file;	const char *command;	handle = tracecmd_xml_create(filename, VERSION_STRING);	if (!handle) {		warning("Could not create %s", filename);		return;	}	update_events(cap);	tracecmd_xml_start_system(handle, "CaptureSettings");	tracecmd_xml_start_sub_system(handle, "Events");	if (info->cap_all_events)		tracecmd_xml_write_element(handle, "CaptureType", "all events");	else if ((info->cap_systems && info->cap_systems[0]) ||		 (info->cap_events && info->cap_events[0] >= 0)) {		save_events(cap, handle);	}	tracecmd_xml_end_sub_system(handle);	update_plugin(cap);	if (info->cap_plugin)		tracecmd_xml_write_element(handle, "Plugin", info->cap_plugin);	command = gtk_entry_get_text(GTK_ENTRY(cap->command_entry));	if (command && strlen(command) && !is_just_ws(command))		tracecmd_xml_write_element(handle, "Command", command);	file = gtk_entry_get_text(GTK_ENTRY(cap->file_entry));	if (file && strlen(file) && !is_just_ws(file))		tracecmd_xml_write_element(handle, "File", file);	tracecmd_xml_end_system(handle);	tracecmd_xml_close(handle);}

static void server_io(evutil_socket_t fd, short events, void *private_data){        struct server *server = private_data;        int revents = 0;        if (events & EV_READ) {                revents |= POLLIN;        }        if (events & EV_WRITE) {                revents |= POLLOUT;        }        if (rpc_service(server->rpc, revents) < 0) {                fprintf(stderr, "rpc_service() failed for server/n");                exit(10);        }        update_events(server->rpc, server->read_event, server->write_event);}

// three_hz_loop - 3.3hz loopvoid Copter::three_hz_loop(){    // check if we've lost contact with the ground station    failsafe_gcs_check();#if AC_FENCE == ENABLED    // check if we have breached a fence    fence_check();#endif // AC_FENCE_ENABLED#if SPRAYER == ENABLED    sprayer.update();#endif    update_events();    // update ch6 in flight tuning    tuning();}

/* * This callback is invoked when others (the nfsv4 server) initiates a * NFSv4 CALLBACK sessions to us. * We accept() the connection and create a local rpc server context * for the callback protocol. */static void client_accept(evutil_socket_t s, short events, void *private_data){	struct client *client = private_data;        struct server *server;        struct sockaddr_storage ss;        socklen_t len = sizeof(ss);        int fd;                server = malloc(sizeof(struct server));        if (server == NULL) {                fprintf(stderr, "failed to malloc server structure/n");                exit(10);        }        memset(server, 0, sizeof(*server));        server->next = server_list;        server_list = server;        if ((fd = accept(s, (struct sockaddr *)&ss, &len)) < 0) {                free_server(server);                fprintf(stderr, "accept failed/n");                exit(10);        }        evutil_make_socket_nonblocking(fd);        server->rpc = rpc_init_server_context(fd);        if (server->rpc == NULL) {                free_server(server);                fprintf(stderr, "Failed to create server rpc context/n");                exit(10);        }        rpc_register_service(server->rpc, NFS4_CALLBACK, NFS_CB,                             pt, sizeof(pt) / sizeof(pt[0]));        server->read_event = event_new(base, fd, EV_READ|EV_PERSIST,                                       server_io, server);        server->write_event = event_new(base, fd, EV_WRITE|EV_PERSIST,                                        server_io, server);        update_events(server->rpc, server->read_event, server->write_event);}

void handle_pcap_read_result(struct npool *ms, struct nevent *nse, enum nse_status status) {  struct niod *iod = nse->iod;  mspcap *mp = (mspcap *)iod->pcap;  switch (status) {    case NSE_STATUS_TIMEOUT:      nse->status = NSE_STATUS_TIMEOUT;      nse->event_done = 1;      break;    case NSE_STATUS_CANCELLED:      nse->status = NSE_STATUS_CANCELLED;      nse->event_done = 1;      break;    case NSE_STATUS_SUCCESS:      /* check if we already have something read */      if (fs_length(&(nse->iobuf)) == 0) {        nse->status = NSE_STATUS_TIMEOUT;        nse->event_done = 0;      } else {        nse->status = NSE_STATUS_SUCCESS; /* we have full buffer */        nse->event_done = 1;      }      break;    default:      fatal("Unknown status (%d) for nsock event #%lu", status, nse->id);  }  /* If there are no more read events, we are done reading on the socket so we   * can take it off the descriptor list... */  if (nse->event_done && mp->pcap_desc >= 0) {    int ev;    ev = socket_count_readpcap_dec(iod);    update_events(iod, ms, EV_NONE, ev);  }}

static PDDebugState update(void* user_data, PDAction action, PDReader* reader, PDWriter* writer) {    PluginData* plugin = (PluginData*)user_data;    plugin->has_updated_registers = false;    plugin->has_updated_exception_location = false;    on_action(plugin, action);    process_events(plugin, reader, writer);    update_events(plugin);    if (plugin->has_updated_registers) {        log_debug("sending registens/n", "");        PDWrite_event_begin(writer, PDEventType_SetRegisters);        PDWrite_array_begin(writer, "registers");        write_status_registers(writer, "flags", plugin->regs.flags);        write_register(writer, "pc", 2, plugin->regs.pc, 1);        write_register(writer, "sp", 1, plugin->regs.sp, 0);        write_register(writer, "a", 1, plugin->regs.a, 0);        write_register(writer, "x", 1, plugin->regs.x, 0);        write_register(writer, "y", 1, plugin->regs.y, 0);        PDWrite_array_end(writer);        PDWrite_event_end(writer);    }    if (plugin->has_updated_exception_location) {        PDWrite_event_begin(writer, PDEventType_SetExceptionLocation);        PDWrite_u64(writer, "address", plugin->regs.pc);        PDWrite_u8(writer, "address_size", 2);        PDWrite_event_end(writer);    }    return plugin->state;}

void handle_read_result(struct npool *ms, struct nevent *nse, enum nse_status status) {  unsigned int count;  char *str;  int rc, len;  struct niod *iod = nse->iod;  if (status == NSE_STATUS_TIMEOUT) {    nse->event_done = 1;    if (fs_length(&nse->iobuf) > 0)      nse->status = NSE_STATUS_SUCCESS;    else      nse->status = NSE_STATUS_TIMEOUT;  } else if (status == NSE_STATUS_CANCELLED) {    nse->status = status;    nse->event_done = 1;  } else if (status == NSE_STATUS_SUCCESS) {    rc = do_actual_read(ms, nse);    /* printf("DBG: Just read %d new bytes%s./n", rc, iod->ssl? "( SSL!)" : ""); */    if (rc > 0) {      nse->iod->read_count += rc;      /* We decide whether we have read enough to return */      switch (nse->readinfo.read_type) {        case NSOCK_READ:          nse->status = NSE_STATUS_SUCCESS;          nse->event_done = 1;          break;        case NSOCK_READBYTES:          if (fs_length(&nse->iobuf) >= nse->readinfo.num) {            nse->status = NSE_STATUS_SUCCESS;            nse->event_done = 1;          }          /* else we are not done */          break;        case NSOCK_READLINES:          /* Lets count the number of lines we have ... */          count = 0;          len = fs_length(&nse->iobuf) -1;          str = fs_str(&nse->iobuf);          for (count=0; len >= 0; len--) {            if (str[len] == '/n') {              count++;              if ((int)count >= nse->readinfo.num)                break;            }          }          if ((int) count >= nse->readinfo.num) {            nse->event_done = 1;            nse->status = NSE_STATUS_SUCCESS;          }          /* Else we are not done */          break;        default:          fatal("Unknown operation type (%d)", (int)nse->readinfo.read_type);      }    }  } else {    fatal("Unknown status (%d)", status);  }  /* If there are no more reads for this IOD, we are done reading on the socket   * so we can take it off the descriptor list ... */  if (nse->event_done && iod->sd >= 0) {    int ev = EV_NONE;#if HAVE_OPENSSL    if (nse->iod->ssl != NULL)      ev |= socket_count_dec_ssl_desire(nse);    else#endif      ev |= socket_count_read_dec(nse->iod);    update_events(nse->iod, ms, EV_NONE, ev);  }}

/* Returns -1 if an error, otherwise the number of newly written bytes */static int do_actual_read(struct npool *ms, struct nevent *nse) {  char buf[8192];  int buflen = 0;  struct niod *iod = nse->iod;  int err = 0;  int max_chunk = NSOCK_READ_CHUNK_SIZE;  int startlen = fs_length(&nse->iobuf);  if (nse->readinfo.read_type == NSOCK_READBYTES)    max_chunk = nse->readinfo.num;  if (!iod->ssl) {    do {      struct sockaddr_storage peer;      socklen_t peerlen;      peerlen = sizeof(peer);      buflen = recvfrom(iod->sd, buf, sizeof(buf), 0, (struct sockaddr *)&peer, &peerlen);      /* Using recv() was failing, at least on UNIX, for non-network sockets       * (i.e. stdin) in this case, a read() is done - as on ENOTSOCK we may       * have a non-network socket */      if (buflen == -1) {        if (socket_errno() == ENOTSOCK) {          peer.ss_family = AF_UNSPEC;          peerlen = 0;          buflen = read(iod->sd, buf, sizeof(buf));        }      }      if (buflen == -1) {        err = socket_errno();        break;      }      if (peerlen > 0) {        assert(peerlen <= sizeof(iod->peer));        memcpy(&iod->peer, &peer, peerlen);        iod->peerlen = peerlen;      }      if (buflen > 0) {        if (fs_cat(&nse->iobuf, buf, buflen) == -1) {          nse->event_done = 1;          nse->status = NSE_STATUS_ERROR;          nse->errnum = ENOMEM;          return -1;        }        /* Sometimes a service just spews and spews data.  So we return after a         * somewhat large amount to avoid monopolizing resources and avoid DOS         * attacks. */        if (fs_length(&nse->iobuf) > max_chunk)          return fs_length(&nse->iobuf) - startlen;        /* No good reason to read again if we we were successful in the read but         * didn't fill up the buffer.  Especially for UDP, where we want to         * return only one datagram at a time. The consistency of the above         * assignment of iod->peer depends on not consolidating more than one         * UDP read buffer. */        if (buflen > 0 && buflen < sizeof(buf))          return fs_length(&nse->iobuf) - startlen;      }    } while (buflen > 0 || (buflen == -1 && err == EINTR));    if (buflen == -1) {      if (err != EINTR && err != EAGAIN) {        nse->event_done = 1;        nse->status = NSE_STATUS_ERROR;        nse->errnum = err;        return -1;      }    }  } else {#if HAVE_OPENSSL    /* OpenSSL read */    while ((buflen = SSL_read(iod->ssl, buf, sizeof(buf))) > 0) {      if (fs_cat(&nse->iobuf, buf, buflen) == -1) {        nse->event_done = 1;        nse->status = NSE_STATUS_ERROR;        nse->errnum = ENOMEM;        return -1;      }      /* Sometimes a service just spews and spews data.  So we return       * after a somewhat large amount to avoid monopolizing resources       * and avoid DOS attacks. */      if (fs_length(&nse->iobuf) > max_chunk)        return fs_length(&nse->iobuf) - startlen;    }    if (buflen == -1) {      err = SSL_get_error(iod->ssl, buflen);      if (err == SSL_ERROR_WANT_READ) {        int evclr;        evclr = socket_count_dec_ssl_desire(nse);        socket_count_read_inc(iod);        update_events(iod, ms, EV_READ, evclr);        nse->sslinfo.ssl_desire = err;      } else if (err == SSL_ERROR_WANT_WRITE) {//.........这里部分代码省略.........

void handle_write_result(struct npool *ms, struct nevent *nse, enum nse_status status) {  int bytesleft;  char *str;  int res;  int err;  struct niod *iod = nse->iod;  if (status == NSE_STATUS_TIMEOUT || status == NSE_STATUS_CANCELLED) {    nse->event_done = 1;    nse->status = status;  } else if (status == NSE_STATUS_SUCCESS) {    str = fs_str(&nse->iobuf) + nse->writeinfo.written_so_far;    bytesleft = fs_length(&nse->iobuf) - nse->writeinfo.written_so_far;    if (nse->writeinfo.written_so_far > 0)      assert(bytesleft > 0);#if HAVE_OPENSSL    if (iod->ssl)      res = SSL_write(iod->ssl, str, bytesleft);    else#endif      if (nse->writeinfo.dest.ss_family == AF_UNSPEC)        res = send(nse->iod->sd, str, bytesleft, 0);      else        res = sendto(nse->iod->sd, str, bytesleft, 0, (struct sockaddr *)&nse->writeinfo.dest, (int)nse->writeinfo.destlen);    if (res == bytesleft) {      nse->event_done = 1;      nse->status = NSE_STATUS_SUCCESS;    } else if (res >= 0) {      nse->writeinfo.written_so_far += res;    } else {      assert(res == -1);      if (iod->ssl) {#if HAVE_OPENSSL        err = SSL_get_error(iod->ssl, res);        if (err == SSL_ERROR_WANT_READ) {          int evclr;          evclr = socket_count_dec_ssl_desire(nse);          socket_count_read_inc(iod);          update_events(iod, ms, EV_READ, evclr);          nse->sslinfo.ssl_desire = err;        } else if (err == SSL_ERROR_WANT_WRITE) {          int evclr;          evclr = socket_count_dec_ssl_desire(nse);          socket_count_write_inc(iod);          update_events(iod, ms, EV_WRITE, evclr);          nse->sslinfo.ssl_desire = err;        } else {          /* Unexpected error */          nse->event_done = 1;          nse->status = NSE_STATUS_ERROR;          nse->errnum = EIO;        }#endif      } else {        err = socket_errno();        if (errcode_is_failure(err)) {          nse->event_done = 1;          nse->status = NSE_STATUS_ERROR;          nse->errnum = err;        }      }    }    if (res >= 0)      nse->iod->write_count += res;  }  if (nse->event_done && nse->iod->sd != -1) {    int ev = EV_NONE;#if HAVE_OPENSSL    if (nse->iod->ssl != NULL)      ev |= socket_count_dec_ssl_desire(nse);    else#endif      ev |= socket_count_write_dec(nse->iod);    update_events(nse->iod, ms, EV_NONE, ev);  }}

//.........这里部分代码省略.........          fatal("SSL_set_tlsext_host_name failed: %s", ERR_error_string(ERR_get_error(), NULL));      }#endif      /* Associate our new SSL with the connected socket.  It will inherit the       * non-blocking nature of the sd */      if (SSL_set_fd(iod->ssl, iod->sd) != 1)        fatal("SSL_set_fd failed: %s", ERR_error_string(ERR_get_error(), NULL));      /* Event not done -- need to do SSL connect below */      nse->sslinfo.ssl_desire = SSL_ERROR_WANT_CONNECT;#endif    } else {      /* This is not an SSL connect (in which case we are always done), or the       * TCP connect() underlying the SSL failed (in which case we are also done */      nse->event_done = 1;    }  } else {    fatal("Unknown status (%d)", status);  }  /* At this point the TCP connection is done, whether successful or not.   * Therefore decrease the read/write listen counts that were incremented in   * nsock_pool_add_event. In the SSL case, we may increase one of the counts depending   * on whether SSL_connect returns an error of SSL_ERROR_WANT_READ or   * SSL_ERROR_WANT_WRITE. In that case we will re-enter this function, but we   * don't want to execute this block again. */  if (iod->sd != -1 && !sslconnect_inprogress) {    int ev = EV_NONE;    ev |= socket_count_read_dec(iod);    ev |= socket_count_write_dec(iod);    ev |= EV_EXCEPT;    update_events(iod, ms, EV_NONE, ev);  }#if HAVE_OPENSSL  if (nse->type == NSE_TYPE_CONNECT_SSL && !nse->event_done) {    /* Lets now start/continue/finish the connect! */    if (iod->ssl_session) {      rc = SSL_set_session(iod->ssl, iod->ssl_session);      if (rc == 0)        nsock_log_error("Uh-oh: SSL_set_session() failed - please tell [email
C++ update_file函数代码示例
C++ update_display函数代码示例