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

/** Clean up a UPing structure, reporting results to the requester. * @param[in,out] pptr UPing results. */void uping_end(struct UPing* pptr){  Debug((DEBUG_DEBUG, "uping_end: %p", pptr));  if (pptr->client) {    if (pptr->lastsent) {      if (0 < pptr->received) {	sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING %s%s",		      pptr->client, pptr->name, pptr->buf);	sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING Stats: "		      "sent %d recvd %d ; min/avg/max = %u/%u/%u ms",		      pptr->client, pptr->sent, pptr->received, pptr->ms_min,		      (2 * pptr->ms_ave) / (2 * pptr->received), pptr->ms_max);      } else	sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING: no response "		      "from %s within %d seconds", pptr->client, pptr->name,		      UPINGTIMEOUT);    } else      sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING: Could not "		    "start ping to %s", pptr->client, pptr->name);  }  close(pptr->fd);  pptr->fd = -1;  uping_erase(pptr);  if (pptr->client)    ClearUPing(pptr->client);  if (pptr->freeable & UPING_PENDING_SOCKET)    socket_del(&pptr->socket);  if (pptr->freeable & UPING_PENDING_SENDER)    timer_del(&pptr->sender);  if (pptr->freeable & UPING_PENDING_KILLER)    timer_del(&pptr->killer);}

/** Start sending upings to a server. * @param[in] sptr Client requesting the upings. * @param[in] aconf ConfItem containing the address to ping. * @param[in] port Port number to ping. * @param[in] count Number of times to ping (should be at least 20). * @return Zero. */int uping_server(struct Client* sptr, struct ConfItem* aconf, int port, int count){  int fd;  struct UPing* pptr;  assert(0 != sptr);  assert(0 != aconf);  if (INADDR_NONE == aconf->ipnum.s_addr) {    sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :UPING: Host lookup failed for "		  "%s", sptr, aconf->name);    return 0;  }  if (IsUPing(sptr))    uping_cancel(sptr, sptr);  /* Cancel previous ping request */  if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {    sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :UPING: Unable to create udp "		  "ping socket", sptr);    return 0;  }  if (!os_set_nonblocking(fd)) {    sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :UPING: Can't set fd non-"		  "blocking", sptr);    close(fd);    return 0;  }  pptr = (struct UPing*) MyMalloc(sizeof(struct UPing));  assert(0 != pptr);  memset(pptr, 0, sizeof(struct UPing));  if (!socket_add(&pptr->socket, uping_read_callback, (void*) pptr,		  SS_DATAGRAM, SOCK_EVENT_READABLE, fd)) {    sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :UPING: Can't queue fd for "		  "reading", sptr);    close(fd);    MyFree(pptr);    return 0;  }  pptr->fd                  = fd;  pptr->sin.sin_port        = htons(port);  pptr->sin.sin_addr.s_addr = aconf->ipnum.s_addr;  pptr->sin.sin_family      = AF_INET;  pptr->count               = IRCD_MIN(20, count);  pptr->client              = sptr;  pptr->index               = -1;  pptr->freeable            = UPING_PENDING_SOCKET;  strcpy(pptr->name, aconf->name);  pptr->next = pingList;  pingList   = pptr;  SetUPing(sptr);  uping_start(pptr);  return 0;}

/** Start sending upings to a server. * @param[in] sptr Client requesting the upings. * @param[in] aconf ConfItem containing the address to ping. * @param[in] port Port number to ping. * @param[in] count Number of times to ping (should be at least 20). * @return Zero. */int uping_server(struct Client* sptr, struct ConfItem* aconf, int port, int count){  int fd;  int family = 0;  struct UPing* pptr;  struct irc_sockaddr *local;  assert(0 != sptr);  assert(0 != aconf);  if (!irc_in_addr_valid(&aconf->address.addr)) {    sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :UPING: Host lookup failed for "		  "%s", sptr, aconf->name);    return 0;  }  if (IsUPing(sptr))    uping_cancel(sptr, sptr);  /* Cancel previous ping request */  if (irc_in_addr_is_ipv4(&aconf->address.addr)) {    local = &VirtualHost_v4;    family = AF_INET;  } else {    local = &VirtualHost_v6;  }  fd = os_socket(local, SOCK_DGRAM, "Outbound uping socket", family);  if (fd < 0)    return 0;  pptr = (struct UPing*) MyMalloc(sizeof(struct UPing));  assert(0 != pptr);  memset(pptr, 0, sizeof(struct UPing));  if (!socket_add(&pptr->socket, uping_read_callback, (void*) pptr,		  SS_DATAGRAM, SOCK_EVENT_READABLE, fd)) {    sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :UPING: Can't queue fd for "		  "reading", sptr);    close(fd);    MyFree(pptr);    return 0;  }  pptr->fd                  = fd;  memcpy(&pptr->addr.addr, &aconf->address.addr, sizeof(pptr->addr.addr));  pptr->addr.port           = port;  pptr->count               = IRCD_MIN(20, count);  pptr->client              = sptr;  pptr->freeable            = UPING_PENDING_SOCKET;  strcpy(pptr->name, aconf->name);  pptr->next = pingList;  pingList   = pptr;  SetUPing(sptr);  uping_start(pptr);  return 0;}

/* * ms_rping - server message handler * -- by Run * *    parv[0] = sender (sptr->name thus) * if sender is a person: (traveling towards start server) *    parv[1] = pinged server[mask] *    parv[2] = start server (current target) *    parv[3] = optional remark * if sender is a server: (traveling towards pinged server) *    parv[1] = pinged server (current target) *    parv[2] = original sender (person) *    parv[3] = start time in s *    parv[4] = start time in us *    parv[5] = the optional remark */int ms_rping(struct Client* cptr, struct Client* sptr, int parc, char* parv[]){  struct Client* destination = 0;  assert(0 != cptr);  assert(0 != sptr);  assert(IsServer(cptr));  /*   * shouldn't happen   */  if (!IsPrivileged(sptr))    return 0;  if (IsServer(sptr)) {    if (parc < 6) {      /*       * PROTOCOL ERROR       */      return need_more_params(sptr, "RPING");    }    if ((destination = FindNServer(parv[1]))) {      /*       * if it's not for me, pass it on       */      if (IsMe(destination))	sendcmdto_one(&me, CMD_RPONG, sptr, "%s %s %s %s :%s", cli_name(sptr),		      parv[2], parv[3], parv[4], parv[5]);      else	sendcmdto_one(sptr, CMD_RPING, destination, "%C %s %s %s :%s",		      destination, parv[2], parv[3], parv[4], parv[5]);    }  }  else {    if (parc < 3) {      return need_more_params(sptr, "RPING");    }    /*     * Haven't made it to the start server yet, if I'm not the start server     * pass it on.     */    if (hunt_server_cmd(sptr, CMD_RPING, cptr, 1, "%s %C :%s", 2, parc, parv)	!= HUNTED_ISME)      return 0;    /*     * otherwise ping the destination from here     */    if ((destination = find_match_server(parv[1]))) {      assert(IsServer(destination) || IsMe(destination));      sendcmdto_one(&me, CMD_RPING, destination, "%C %C %s :%s", destination,		    sptr, militime(0, 0), parv[3]);    }    else      send_reply(sptr, ERR_NOSUCHSERVER, parv[1]);  }  return 0;}

/** Statistics callback to display userload. * @param[in] sptr Client requesting statistics. * @param[in] sd Stats descriptor for request (ignored). * @param[in] param Extra parameter from user (ignored). */voidcalc_load(struct Client *sptr, const struct StatDesc *sd, char *param){  /* *INDENT-OFF* */  static const char *header =  /*   ----.-  ----.-  ----  ----  ----   ------------ */      "Minute  Hour    Day   Yest. YYest. Userload for:";  /* *INDENT-ON* */  static const char *what[3] = {    "local clients",    "total clients",    "total connections"  };  int i, j, times[5][3];        /* [min,hour,day,Yest,YYest]                                   [local,client,conn] */  int last_m_index = m_index, last_h_index = h_index;  update_load();                /* We want stats accurate as of *now* */  if (--last_m_index < 0)    last_m_index = 59;  times[0][0] = (cspm[last_m_index].local_count + 3) / 6;  times[0][1] = (cspm[last_m_index].client_count + 3) / 6;  times[0][2] = (cspm[last_m_index].conn_count + 3) / 6;  times[1][0] = (csph_sum.local_count + 180) / 360;  times[1][1] = (csph_sum.client_count + 180) / 360;  times[1][2] = (csph_sum.conn_count + 180) / 360;  for (i = 2; i < 5; ++i)  {    times[i][0] = 43200;    times[i][1] = 43200;    times[i][2] = 43200;    for (j = 0; j < 24; ++j)    {      if (--last_h_index < 0)        last_h_index = 71;      times[i][0] += csph[last_h_index].local_count;      times[i][1] += csph[last_h_index].client_count;      times[i][2] += csph[last_h_index].conn_count;    }    times[i][0] /= 86400;    times[i][1] /= 86400;    times[i][2] /= 86400;  }  sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :%s", sptr, header);  for (i = 0; i < 3; ++i)    sendcmdto_one(&me, CMD_NOTICE, sptr,		  "%C :%4d.%1d  %4d.%1d  %4d  %4d  %4d   %s", sptr,		  times[0][i] / 10, times[0][i] % 10,		  times[1][i] / 10, times[1][i] % 10,		  times[2][i], times[3][i], times[4][i], what[i]);}

/* * ms_kill - server message handler * * NOTE: IsServer(cptr) == true; * * parv[0]      = sender prefix * parv[1]      = kill victim * parv[parc-1] = kill path */int ms_kill(struct Client* cptr, struct Client* sptr, int parc, char* parv[]){  struct Client* victim;  char*          path;  char*          msg;  assert(0 != cptr);  assert(0 != sptr);  assert(IsServer(cptr));  /*   * XXX - a server sending less than 3 params could really desync   * things   */  if (parc < 3) {    protocol_violation(sptr,"Too few arguments for KILL");    return need_more_params(sptr, "KILL");  }  path = parv[parc - 1];        /* Either defined or NULL (parc >= 3) */  if (!(msg = strchr(path, ' '))) /* Extract out the message */    msg = "(No reason supplied)";  else    *(msg++) = '/0'; /* Remove first character (space) and terminate path */  if (!(victim = findNUser(parv[1]))) {    if (IsUser(sptr))      sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :KILL target disconnected "		    "before I got him :(", sptr);    return 0;  }  /*   * We *can* have crossed a NICK with this numeric... --Run   *   * Note the following situation:   *  KILL SAA -->       X   *  <-- S NICK ... SAA | <-- SAA QUIT <-- S NICK ... SAA <-- SQUIT S   * Where the KILL reaches point X before the QUIT does.   * This would then *still* cause an orphan because the KILL doesn't reach S   * (because of the SQUIT), the QUIT is ignored (because of the KILL)   * and the second NICK ... SAA causes an orphan on the server at the   * right (which then isn't removed when the SQUIT arrives).   * Therefore we still need to detect numeric nick collisions too.   *   * Bounce the kill back to the originator, if the client can't be found   * by the next hop (short lag) the bounce won't propagate further.   */  if (MyConnect(victim)) {    sendcmdto_one(&me, CMD_KILL, cptr, "%C :%s (Ghost 5 Numeric Collided)",                  victim, path);  }  return do_kill(cptr, sptr, victim, cli_name(cptr), path, msg);}

/* * mo_kill - oper message handler * * NOTE: IsPrivileged(sptr), IsAnOper(sptr) == true *       IsServer(cptr), IsServer(sptr) == false * * parv[0]      = sender prefix * parv[1]      = kill victim * parv[parc-1] = kill path */int mo_kill(struct Client* cptr, struct Client* sptr, int parc, char* parv[]){  struct Client* victim;  char*          user;  char           msg[TOPICLEN + 3]; /* (, ), and /0 */  assert(0 != cptr);  assert(0 != sptr);  /*   * oper connection to this server, cptr is always sptr   */  assert(cptr == sptr);  assert(IsAnOper(sptr));  if (parc < 3 || EmptyString(parv[parc - 1]))    return need_more_params(sptr, "KILL");  user = parv[1];  ircd_snprintf(0, msg, sizeof(msg), "(%.*s)", TOPICLEN, parv[parc - 1]);  if (!(victim = FindClient(user))) {    /*     * If the user has recently changed nick, we automaticly     * rewrite the KILL for this new nickname--this keeps     * servers in synch when nick change and kill collide     */    if (!(victim = get_history(user, (long)15)))      return send_reply(sptr, ERR_NOSUCHNICK, user);    sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :Changed KILL %s into %s", sptr,		  user, cli_name(victim));  }  if (!HasPriv(sptr, MyConnect(victim) ? PRIV_LOCAL_KILL : PRIV_KILL))    return send_reply(sptr, ERR_NOPRIVILEGES);  if (IsServer(victim) || IsMe(victim)) {    return send_reply(sptr, ERR_CANTKILLSERVER);  }  /*   * if the user is +k, prevent a kill from local user   */  if (IsChannelService(victim))    return send_reply(sptr, ERR_ISCHANSERVICE, "KILL", cli_name(victim));  if (!MyConnect(victim) && !HasPriv(sptr, PRIV_KILL)) {    sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :Nick %s isnt on your server",		  sptr, cli_name(victim));    return 0;  }  return do_kill(cptr, sptr, victim, cli_user(sptr)->host, cli_name(sptr),		 msg);}

/* * ms_ping - server message handler */int ms_ping(struct Client* cptr, struct Client* sptr, int parc, char* parv[]){  struct Client* acptr;  char*          origin;  char*          destination;  assert(0 != cptr);  assert(0 != sptr);  assert(IsServer(cptr));  if (parc < 2 || EmptyString(parv[1])) {    /*     * don't bother sending the error back     */    return 0;  }  origin      = parv[1];  destination = parv[2];        /* Will get NULL or pointer (parc >= 2!!) */  if (parc > 3)  {    /* AsLL ping, send reply back */    int diff = atoi(militime_float(parv[3]));    sendcmdto_one(&me, CMD_PONG, sptr, "%C %s %s %i %s", &me, origin,                  parv[3], diff, militime_float(NULL));    return 0;  }  if (!EmptyString(destination) && 0 != ircd_strcmp(destination, cli_name(&me))) {    if ((acptr = FindServer(destination))) {      /*       * Servers can just forward the origin       */      sendcmdto_one(sptr, CMD_PING, acptr, "%s :%s", origin, destination);    }    else {      /*       * this can happen if server split before the ping got here       */      send_reply(sptr, ERR_NOSUCHSERVER, destination);    }  }  else {    /*     * send pong back     * NOTE:  sptr is never local so if pong handles numerics everywhere we     * could send a numeric here.     */    sendcmdto_one(&me, CMD_PONG, sptr, "%C :%s", &me, origin);  }  return 0;}

void server_relay_private_notice(struct Client* sptr, const char* name, const char* text){  struct Client* acptr;  assert(0 != sptr);  assert(0 != name);  assert(0 != text);  /*   * nickname addressed?   */  if (0 == (acptr = findNUser(name)) || !IsUser(acptr))    return;  if (!IsChannelService(sptr) && is_silenced(sptr, acptr))  {    send_reply(sptr, ERR_SILENCED, cli_name(acptr));    return;  }  if (IsOnlyreg(acptr) && !IsRegnick(sptr)) {	  send_reply(sptr, RPL_MSGONLYREG, cli_name(acptr));	  return;  }  if (MyUser(acptr))    add_target(acptr, sptr);  sendcmdto_one(sptr, CMD_NOTICE, acptr, "%C :%s", acptr, text);}

void server_relay_private_message(struct Client* sptr, const char* name, const char* text){  struct Client* acptr;  assert(0 != sptr);  assert(0 != name);  assert(0 != text);  /*   * nickname addressed?   */  if (0 == (acptr = findNUser(name)) || !IsUser(acptr)) {    send_reply(sptr, SND_EXPLICIT | ERR_NOSUCHNICK, "* :Target left %s. "	       "Failed to deliver: [%.20s]", feature_str(FEAT_NETWORK), text);    return;  }  if (!IsChannelService(sptr) && is_silenced(sptr, acptr))  {    send_reply(sptr, ERR_SILENCED, cli_name(acptr));    return;  }  if (IsOnlyreg(acptr) && !IsRegnick(sptr)) {	  send_reply(sptr, RPL_MSGONLYREG, cli_name(acptr));	  return;  }  if (MyUser(acptr))    add_target(acptr, sptr);  sendcmdto_one(sptr, CMD_PRIVATE, acptr, "%C :%s", acptr, text);}

void relay_private_notice(struct Client* sptr, const char* name, const char* text){  struct Client* acptr;  assert(0 != sptr);  assert(0 != name);  assert(0 != text);  if (0 == (acptr = FindUser(name)))    return;  if (IsOnlyreg(acptr) && !IsRegnick(sptr)) {	  send_reply(sptr, RPL_MSGONLYREG, cli_name(acptr));	  return;  }  if (!IsChannelService(acptr))  {    if (check_target_limit(sptr, acptr, cli_name(acptr), 0))    {      return;    }    if (is_silenced(sptr, acptr))    {      send_reply(sptr, ERR_SILENCED, cli_name(acptr));      return;    }  }      /*   * deliver the message   */  if (MyUser(acptr))    add_target(acptr, sptr);  sendcmdto_one(sptr, CMD_NOTICE, acptr, "%C :%s", acptr, text);}

/* * ms_end_of_burst - server message handler * - Added Xorath 6-14-96, rewritten by Run 24-7-96 * - and fixed by record and Kev 8/1/96 * - and really fixed by Run 15/8/96 :p * This the last message in a net.burst. * It clears a flag for the server sending the burst. * * As of 10.11, to fix a bug in the way BURST is processed, it also * makes sure empty channels are deleted * * parv[0] - sender prefix */int ms_end_of_burst(struct Client* cptr, struct Client* sptr, int parc, char* parv[]){  struct Channel *chan, *next_chan;  assert(0 != cptr);  assert(0 != sptr);  sendto_opmask_butone(0, SNO_NETWORK, "Completed net.burst from %C.",   	sptr);  sendcmdto_serv_butone(sptr, CMD_END_OF_BURST, cptr, "");  ClearBurst(sptr);  SetBurstAck(sptr);  if (MyConnect(sptr))    sendcmdto_one(&me, CMD_END_OF_BURST_ACK, sptr, "");  /* Count through channels... */  for (chan = GlobalChannelList; chan; chan = next_chan) {    next_chan = chan->next;    if (!chan->members && (chan->mode.mode & MODE_BURSTADDED)) {      /* Newly empty channel, schedule it for removal. */      chan->mode.mode &= ~MODE_BURSTADDED;      sub1_from_channel(chan);   } else      chan->mode.mode &= ~MODE_BURSTADDED;  }  return 0;}

/** Set a channel topic or report an error. * @param[in] sptr Original topic setter. * @param[in] cptr Neighbor that sent the topic message. * @param[in] chptr Channel to set topic on. * @param[in] topic New topic. * @param[in] ts Timestamp that topic was set (0 for current time). */static void do_settopic(struct Client *sptr, struct Client *cptr,                        struct Channel *chptr, char *topic, time_t ts){    struct Client *from;    int newtopic;    if (feature_bool(FEAT_HIS_BANWHO) && IsServer(sptr))        from = &his;    else        from = sptr;    /* Note if this is just a refresh of an old topic, and don't     * send it to all the clients to save bandwidth.  We still send     * it to other servers as they may have split and lost the topic.     */    newtopic=ircd_strncmp(chptr->topic,topic,TOPICLEN)!=0;    /* setting a topic */    ircd_strncpy(chptr->topic, topic, TOPICLEN);    ircd_strncpy(chptr->topic_nick, cli_name(from), NICKLEN);    chptr->topic_time = ts ? ts : TStime();    /* Fixed in 2.10.11: Don't propagate local topics */    if (!IsLocalChannel(chptr->chname))        sendcmdto_serv(sptr, CMD_TOPIC, cptr, "%H %Tu %Tu :%s", chptr,                       chptr->creationtime, chptr->topic_time, chptr->topic);    if (newtopic)        sendcmdto_channel(from, CMD_TOPIC, chptr, NULL, SKIP_SERVERS,                          "%H :%s", chptr, chptr->topic);    /* if this is the same topic as before we send it to the person that     * set it (so they knew it went through ok), but don't bother sending     * it to everyone else on the channel to save bandwidth     */    else if (MyUser(sptr))        sendcmdto_one(sptr, CMD_TOPIC, sptr, "%H :%s", chptr, chptr->topic);}

/** Send a uping to another server. * @param[in] pptr Descriptor for uping. */void uping_send(struct UPing* pptr){  struct timeval tv;  char buf[BUFSIZE + 1];  assert(0 != pptr);  if (pptr->sent == pptr->count)    return;  memset(buf, 0, sizeof(buf));  gettimeofday(&tv, NULL);  sprintf(buf, " %10lu%c%6lu", (unsigned long)tv.tv_sec, '/0', (unsigned long)tv.tv_usec);  Debug((DEBUG_SEND, "send_ping: sending [%s %s] to %s.%d on %d",	  buf, &buf[12],          ircd_ntoa(&pptr->addr.addr), pptr->addr.port,	  pptr->fd));  if (os_sendto_nonb(pptr->fd, buf, BUFSIZE, NULL, 0, &pptr->addr) != IO_SUCCESS)  {    const char* msg = strerror(errno);    if (!msg)      msg = "Unknown error";    if (pptr->client)      sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING: send failed: "		    "%s", pptr->client, msg);    Debug((DEBUG_DEBUG, "UPING: send_ping: sendto failed on %d: %s", pptr->fd, msg));    uping_end(pptr);    return;  }  ++pptr->sent;}

/* * mo_asll - oper message handler */int mo_asll(struct Client* cptr, struct Client* sptr, int parc, char* parv[]){  char *mask;  struct Client *acptr;  int hits;  int i;  if (parc < 2)    return need_more_params(sptr, "ASLL");  if (parc == 2 && MyUser(sptr))    parv[parc++] = cli_name(&me);  if (hunt_server_prio_cmd(sptr, CMD_ASLL, cptr, 1, "%s %C", 2, parc, parv) != HUNTED_ISME)    return 0;  mask = parv[1];  for (i = hits = 0; i <= HighestFd; i++) {    acptr = LocalClientArray[i];    if (!acptr || !IsServer(acptr) || !MyConnect(acptr) || match(mask, cli_name(acptr)))      continue;    send_asll_reply(&me, sptr, cli_name(acptr), cli_serv(acptr)->asll_rtt,      cli_serv(acptr)->asll_to, cli_serv(acptr)->asll_from);    hits++;  }  sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :AsLL for %s: %d local servers matched", sptr, mask, hits);  return 0;}

/** Send a uping to another server. * @param[in] pptr Descriptor for uping. */void uping_send(struct UPing* pptr){  struct timeval tv;  char buf[BUFSIZE + 1];  assert(0 != pptr);  if (pptr->sent == pptr->count)    return;  memset(buf, 0, sizeof(buf));  gettimeofday(&tv, NULL);  sprintf(buf, " %10lu%c%6lu", (long unsigned int)tv.tv_sec, '/0', tv.tv_usec);  Debug((DEBUG_SEND, "send_ping: sending [%s %s] to %s.%d on %d",	  buf, &buf[12],          ircd_ntoa((const char*) &pptr->sin.sin_addr), ntohs(pptr->sin.sin_port),	  pptr->fd));  if (sendto(pptr->fd, buf, BUFSIZE, 0, (struct sockaddr*) &pptr->sin,             sizeof(struct sockaddr_in)) != BUFSIZE)  {    const char* msg = strerror(errno);    if (!msg)      msg = "Unknown error";    if (pptr->client)      sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING: send failed: "		    "%s", pptr->client, msg);    Debug((DEBUG_DEBUG, "UPING: send_ping: sendto failed on %d: %s", pptr->fd, msg));    uping_end(pptr);    return;  }  ++pptr->sent;}

/* * ms_oper - server message handler */int ms_oper(struct Client* cptr, struct Client* sptr, int parc, char* parv[]){  struct Client *acptr;  struct ConfItem *aconf;  assert(0 != cptr);  assert(IsServer(cptr));  /*   * if message arrived from server, trust it, and set to oper   */  if (!IsServer(sptr) && !IsOper(sptr)) {    if (parc < 4)      return send_reply(sptr, ERR_NOOPERHOST);    if (!(acptr = FindNServer(parv[1])))      return send_reply(sptr, ERR_NOOPERHOST);    else if (!IsMe(acptr)) {      sendcmdto_one(sptr, CMD_OPER, acptr, "%C %s %s", acptr, parv[2],                    parv[3]);      return 0;    }    if (can_oper(cptr, sptr, parv[2], parv[3], &aconf))      do_oper(cptr, sptr, aconf);  } else if (!IsServer(sptr))    send_reply(sptr, RPL_YOUREOPER);  return 0;}

void relay_directed_notice(struct Client* sptr, char* name, char* server, const char* text){  struct Client* acptr;  char*          host;  assert(0 != sptr);  assert(0 != name);  assert(0 != text);  assert(0 != server);  if (0 == (acptr = FindServer(server + 1)))    return;  /*   * NICK[%host]@server addressed? See if <server> is me first   */  if (!IsMe(acptr)) {    sendcmdto_one(sptr, CMD_NOTICE, acptr, "%s :%s", name, text);    return;  }  /*   * Look for an user whose NICK is equal to <name> and then   * check if it's hostname matches <host> and if it's a local   * user.   */  *server = '/0';  if ((host = strchr(name, '%')))    *host++ = '/0';  if (!(acptr = FindUser(name)) || !MyUser(acptr) ||      (!EmptyString(host) && 0 != match(host, cli_user(acptr)->realhost)))    return;  *server = '@';  if (host)    *--host = '%';  if (!IsChannelService(sptr) && is_silenced(sptr, acptr))  {    send_reply(sptr, ERR_SILENCED, cli_name(acptr));    return;  }  if (IsOnlyreg(acptr) && !IsRegnick(sptr))    send_reply(sptr, RPL_MSGONLYREG, cli_name(acptr));  else    sendcmdto_one(sptr, CMD_NOTICE, acptr, "%s :%s", name, text);}

int proto_send_supported(struct Client* cptr){  /*   * send_reply(cptr, RPL_PROTOLIST, "stuff");   */  sendcmdto_one(&me,CMD_PROTO,cptr,"%s unet1 1 1",PROTO_SUP);  return 0;}

int m_hash(struct Client *cptr, struct Client *sptr, int parc, char *parv[]){    int max_chain = 0;    int buckets   = 0;    int count     = 0;    struct Client*  cl;    struct Channel* ch;    int i;    sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :Hash Table Statistics", sptr);    for (i = 0; i < HASHSIZE; ++i) {        if ((cl = clientTable[i])) {            int len = 0;            ++buckets;            for ( ; cl; cl = cli_hnext(cl))                ++len;            if (len > max_chain)                max_chain = len;            count += len;        }    }    sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :Client: entries: %d buckets: %d "                  "max chain: %d", sptr, count, buckets, max_chain);    buckets = 0;    count   = 0;    max_chain = 0;    for (i = 0; i < HASHSIZE; ++i) {        if ((ch = channelTable[i])) {            int len = 0;            ++buckets;            for ( ; ch; ch = ch->hnext)                ++len;            if (len > max_chain)                max_chain = len;            count += len;        }    }    sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :Channel: entries: %d buckets: %d "                  "max chain: %d", sptr, count, buckets, max_chain);    return 0;}

/* * m_help - generic message handler */int m_help(struct Client* cptr, struct Client* sptr, int parc, char* parv[]){  int i;  for (i = 0; msgtab[i].cmd; i++)    sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :%s", sptr, msgtab[i].cmd);  return 0;}

/* * ms_uping - server message handler * * m_uping  -- by Run * * parv[0] = sender prefix * parv[1] = pinged server * parv[2] = port * parv[3] = hunted server * parv[4] = number of requested pings */int ms_uping(struct Client* cptr, struct Client* sptr, int parc, char* parv[]){  struct ConfItem *aconf;  int port;  int count;  assert(0 != cptr);  assert(0 != sptr);  if (!IsAnOper(sptr)) {    send_reply(sptr, ERR_NOPRIVILEGES);    return 0;  }  if (parc < 5) {    send_reply(sptr, ERR_NEEDMOREPARAMS, "UPING");    return 0;  }  if (hunt_server_cmd(sptr, CMD_UPING, cptr, 1, "%s %s %C %s", 3, parc, parv)      != HUNTED_ISME)    return 0;  /*   * Determine port: First user supplied, then default : 7007   */  if (EmptyString(parv[2]) || (port = atoi(parv[2])) <= 0)    port = atoi(UDP_PORT);  if (EmptyString(parv[4]) || (count = atoi(parv[4])) <= 0)  {    sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :UPING : Illegal number of "		  "packets: %s", sptr, parv[4]);    return 0;  }  /*    * Check if a CONNECT would be possible at all (adapted from m_connect)   */  if ((aconf = conf_find_server(parv[1])))    uping_server(sptr, aconf, port, count);  else    sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :UPING: Host %s not listed in "		  "ircd.conf", sptr, parv[1]);  return 0;}

/* * do_kill - Performs the generic work involved in killing a client * */static int do_kill(struct Client* cptr, struct Client* sptr,		   struct Client* victim, char* inpath, char* path, char* msg){  assert(0 != cptr);  assert(0 != sptr);  assert(!IsServer(victim));  /*   * Notify all *local* opers about the KILL (this includes the one   * originating the kill, if from this server--the special numeric   * reply message is not generated anymore).   *   * Note: "victim->name" is used instead of "user" because we may   *       have changed the target because of the nickname change.   */  sendto_opmask_butone(0, IsServer(sptr) ? SNO_SERVKILL : SNO_OPERKILL,                       "Received KILL message for %s. From %s Path: %s!%s %s",                       get_client_name(victim, SHOW_IP), cli_name(sptr),                       inpath, path, msg);  log_write_kill(victim, sptr, inpath, path, msg);  /*   * And pass on the message to other servers. Note, that if KILL   * was changed, the message has to be sent to all links, also   * back.   * Client suicide kills are NOT passed on --SRB   */  if (IsServer(cptr) || !MyConnect(victim)) {    sendcmdto_serv_butone(sptr, CMD_KILL, cptr, "%C :%s!%s %s", victim,                          inpath, path, msg);    /*     * Set FLAG_KILLED. This prevents exit_one_client from sending     * the unnecessary QUIT for this. (This flag should never be     * set in any other place)     */    SetFlag(victim, FLAG_KILLED);  }  /*   * Tell the victim she/he has been zapped, but *only* if   * the victim is on current server--no sense in sending the   * notification chasing the above kill, it won't get far   * anyway (as this user don't exist there any more either)   * In accordance with the new hiding rules, the victim   * always sees the kill as coming from me.   */  if (MyConnect(victim))    sendcmdto_one(feature_bool(FEAT_HIS_KILLWHO) ? &me : sptr, CMD_KILL, 		  victim, "%C :%s %s", victim, feature_bool(FEAT_HIS_KILLWHO)		  ? feature_str(FEAT_HIS_SERVERNAME) : cli_name(sptr), msg);  return exit_client_msg(cptr, victim, feature_bool(FEAT_HIS_KILLWHO)			 ? &me : sptr, "Killed (%s %s)",			 feature_bool(FEAT_HIS_KILLWHO) ? 			 feature_str(FEAT_HIS_SERVERNAME) : cli_name(sptr),			 msg);}

static int send_asll_reply(struct Client *from, struct Client *to, char *server,			   int rtt, int up, int down){  sendcmdto_one(from, CMD_NOTICE, to,    (up || down) ? "%C :AsLL for %s -- RTT: %ims Upstream: %ims Downstream: %ims" :    rtt ? "%C :AsLL for %s -- RTT: %ims [no asymm info]" :    "%C :AsLL for %s -- [unknown]",    to, server, rtt, up, down);  return 0;}

/* * m_ping - generic message handler * * parv[0] = sender prefix * parv[1] = origin * parv[2] = destination */int m_ping(struct Client* cptr, struct Client* sptr, int parc, char* parv[]){  assert(0 != cptr);  assert(cptr == sptr);  if (parc < 2 || EmptyString(parv[1]))    return send_reply(sptr, ERR_NOORIGIN);  sendcmdto_one(&me, CMD_PONG, sptr, "%C :%s", &me, parv[1]);  return 0;}

static voidstats_help(struct Client* to, struct StatDesc* sd, int stat, char* param){  struct StatDesc *asd;  if (MyUser(to)) /* only if it's my user */    for (asd = statsinfo; asd->sd_c; asd++)      if (asd->sd_c != sd->sd_c) /* don't send the help for us */	sendcmdto_one(&me, CMD_NOTICE, to, "%C :%c - %s", to, asd->sd_c,		      asd->sd_desc);}

/** Handle an RPONG message from a server * -- by Run too :) * * This message is used for reporting the results of remotely * initiated pings.  See ms_rping() for the theory of operation. * * Going from the rping target to the rping source, /a parv has the * following elements: * /li /a parv[1] is the rping source's name (numnick is also allowed) * /li /a parv[2] is the rping requester's numnick * /li /a parv[3] is the rping start time (seconds part) * /li /a parv[4] is the rping start time (microseconds part) * /li /a parv[5] is the requester's remark * * Going from the rping source to the rping requester, /a parv has the * following elements: * /li /a parv[1] is the rping source's name (numnick is also allowed) * /li /a parv[2] is the rping requester's numnick * /li /a parv[3] is the rping round trip time in milliseconds * /li /a parv[4] is the requester's remark * * See @ref m_functions for discussion of the arguments. * @param[in] cptr Client that sent us the message. * @param[in] sptr Original source of message. * @param[in] parc Number of arguments. * @param[in] parv Argument vector. */int ms_rpong(struct Client* cptr, struct Client* sptr, int parc, char* parv[]){  struct Client *acptr;  if (!IsServer(sptr))    return 0;  if (parc < 5) {    /*     * PROTOCOL ERROR     */    return need_more_params(sptr, "RPONG");  }  if (parc == 6) {    /*     * from pinged server to source server     */    if (!(acptr = FindServer(parv[1])) && !(acptr = FindNServer(parv[1])))      return 0;       if (IsMe(acptr)) {      if (!(acptr = findNUser(parv[2])))        return 0;      sendcmdto_one(&me, CMD_RPONG, acptr, "%C %s %s :%s", acptr, cli_name(sptr),		    militime(parv[3], parv[4]), parv[5]);    } else      sendcmdto_one(sptr, CMD_RPONG, acptr, "%s %s %s %s :%s", parv[1],		    parv[2], parv[3], parv[4], parv[5]);  } else {    /*     * returned from source server to client     */    if (!(acptr = findNUser(parv[1])))      return 0;    sendcmdto_one(sptr, CMD_RPONG, acptr, "%C %s %s :%s", acptr, parv[2],		  parv[3], parv[4]);  }  return 0;}

/* * ms_jupe - server message handler * * parv[0] = Send prefix * * From server: * * parv[1] = Target: server numeric or * * parv[2] = (+|-)<server name> * parv[3] = Expiration offset * parv[4] = Last modification time * parv[5] = Comment * */int ms_jupe(struct Client* cptr, struct Client* sptr, int parc, char* parv[]){    struct Client *acptr = 0;    struct Jupe *ajupe;    unsigned int flags = 0;    time_t expire_off, lastmod;    char *server = parv[2], *target = parv[1], *reason = parv[5];    if (parc < 6)        return need_more_params(sptr, "JUPE");    if (!(target[0] == '*' && target[1] == '/0')) {        if (!(acptr = FindNServer(target)))            return 0; /* no such server */        if (!IsMe(acptr)) { /* manually propagate, since we don't set it */            sendcmdto_one(sptr, CMD_JUPE, acptr, "%s %s %s %s :%s", target, server,                          parv[3], parv[4], reason);            return 0;        }        flags |= JUPE_LOCAL;    }    if (*server == '-')        server++;    else if (*server == '+') {        flags |= JUPE_ACTIVE;        server++;    }    expire_off = atoi(parv[3]);    lastmod = atoi(parv[4]);    ajupe = jupe_find(server);    if (ajupe) {        if (JupeIsLocal(ajupe) && !(flags & JUPE_LOCAL)) /* global over local */            jupe_free(ajupe);        else if (JupeLastMod(ajupe) < lastmod) { /* new modification */            if (flags & JUPE_ACTIVE)                return jupe_activate(cptr, sptr, ajupe, lastmod, flags);            else                return jupe_deactivate(cptr, sptr, ajupe, lastmod, flags);        } else if (JupeLastMod(ajupe) == lastmod || IsBurstOrBurstAck(cptr))            return 0;        else            return jupe_resend(cptr, ajupe); /* other server desynched WRT jupes */    }    return jupe_add(cptr, sptr, server, reason, expire_off, lastmod, flags);}

/** Forward a jupe to another server. * @param[in] cptr %Server to send jupe to. * @param[in] jupe Jupe to forward. */intjupe_resend(struct Client *cptr, struct Jupe *jupe){  if (JupeIsLocal(jupe)) /* don't propagate local jupes */    return 0;  sendcmdto_one(&me, CMD_JUPE, cptr, "* %c%s %Tu %Tu :%s",		JupeIsRemActive(jupe) ? '+' : '-', jupe->ju_server,		jupe->ju_expire - CurrentTime, jupe->ju_lastmod,		jupe->ju_reason);  return 0;}

/** Read the response from an outbound uping. * @param[in] pptr UPing to check. */void uping_read(struct UPing* pptr){  struct irc_sockaddr sin;  struct timeval     tv;  unsigned int       len;  unsigned int       pingtime;  char*              s;  char               buf[BUFSIZE + 1];  IOResult           ior;  assert(0 != pptr);  gettimeofday(&tv, NULL);  ior = os_recvfrom_nonb(pptr->fd, buf, BUFSIZE, &len, &sin);  if (IO_BLOCKED == ior)    return;  else if (IO_FAILURE == ior) {    const char* msg = strerror(errno);    if (!msg)      msg = "Unknown error";    sendcmdto_one(&me, CMD_NOTICE, pptr->client, "%C :UPING: receive error: "		  "%s", pptr->client, msg);    uping_end(pptr);    return;  }  if (len < 19)    return;			/* Broken packet */  ++pptr->received;  buf[len] = 0;  pingtime = (tv.tv_sec - atol(&buf[1])) * 1000             + (tv.tv_usec - atol(buf + strlen(buf) + 1)) / 1000;  pptr->ms_ave += pingtime;  if (!pptr->ms_min || pptr->ms_min > pingtime)    pptr->ms_min = pingtime;  if (pingtime > pptr->ms_max)    pptr->ms_max = pingtime;  timer_chg(&pptr->killer, TT_RELATIVE, UPINGTIMEOUT);  s = pptr->buf + strlen(pptr->buf);  sprintf(s, " %u", pingtime);  if (pptr->received == pptr->count)    uping_end(pptr);  return;}