int save_aux(struct sip_msg* _m, str* forced_binding, char* _d, char* _f, char* _s) { struct save_ctx sctx; contact_t* c; contact_t* forced_c = NULL; int st; str uri; str flags_s; pv_value_t val; rerrno = R_FINE; memset( &sctx, 0 , sizeof(sctx)); sctx.max_contacts = -1; sctx.flags = 0; sctx.min_expires = min_expires; sctx.max_expires = max_expires; if ( _f ) { if (fixup_get_svalue( _m, (gparam_p)_f, &flags_s)!=0) { LM_ERR("invalid flags parameter"); return -1; } for( st=0 ; st< flags_s.len ; st++ ) { switch (flags_s.s[st]) { case 'm': sctx.flags |= REG_SAVE_MEMORY_FLAG; break; case 'r': sctx.flags |= REG_SAVE_NOREPLY_FLAG; break; case 's': sctx.flags |= REG_SAVE_SOCKET_FLAG; break; case 'v': sctx.flags |= REG_SAVE_PATH_RECEIVED_FLAG; break; case 'f': sctx.flags |= REG_SAVE_FORCE_REG_FLAG; break; case 'c': sctx.max_contacts = 0; while (st<flags_s.len-1 && isdigit(flags_s.s[st+1])) { sctx.max_contacts = sctx.max_contacts*10 + flags_s.s[st+1] - '0'; st++; } break; case 'e': sctx.min_expires = 0; while (st<flags_s.len-1 && isdigit(flags_s.s[st+1])) { sctx.min_expires = sctx.min_expires*10 + flags_s.s[st+1] - '0'; st++; } break; case 'E': sctx.max_expires = 0; while (st<flags_s.len-1 && isdigit(flags_s.s[st+1])) { sctx.max_expires = sctx.max_expires*10 + flags_s.s[st+1] - '0'; st++; } break; case 'p': if (st<flags_s.len-1) { st++; if (flags_s.s[st]=='2') { sctx.flags |= REG_SAVE_PATH_STRICT_FLAG; break; } if (flags_s.s[st]=='1') { sctx.flags |= REG_SAVE_PATH_LAZY_FLAG; break; } if (flags_s.s[st]=='0') { sctx.flags |= REG_SAVE_PATH_OFF_FLAG; break; } } default: LM_WARN("unsuported flag %c \n",flags_s.s[st]); } } } if(route_type == ONREPLY_ROUTE) sctx.flags |= REG_SAVE_NOREPLY_FLAG; /* if no max_contact per AOR is defined, use the global one */ if (sctx.max_contacts == -1) sctx.max_contacts = max_contacts; if (parse_message(_m) < 0) { goto error; } if (forced_binding) { if (parse_contacts(forced_binding, &forced_c) < 0) { LM_ERR("Unable to parse forced binding [%.*s]\n", forced_binding->len, forced_binding->s); goto error; } /* prevent processing all the headers from the message */ reset_first_contact(); st = 0; c = forced_c; } else { if (check_contacts(_m, &st) > 0) { goto error; } c = get_first_contact(_m); } get_act_time(); if (_s) { if (pv_get_spec_value( _m, (pv_spec_p)_s, &val)!=0) { LM_ERR("failed to get PV value\n"); goto return_minus_one; } if ( (val.flags&PV_VAL_STR)==0 ) { LM_ERR("PV vals is not string\n"); goto return_minus_one; } uri = val.rs; } else { uri = get_to(_m)->uri; } if (extract_aor( &uri, &sctx.aor,0,0) < 0) { LM_ERR("failed to extract Address Of Record\n"); goto error; } if (c == 0) { if (st) { if (star((udomain_t*)_d, &sctx,_m) < 0) goto error; } else { if (no_contacts((udomain_t*)_d, &sctx.aor,_m) < 0) goto error; } } else { if (add_contacts(_m, c, (udomain_t*)_d, &sctx) < 0) goto error; } update_stat(accepted_registrations, 1); if (!is_cflag_set(REG_SAVE_NOREPLY_FLAG) && (send_reply(_m,sctx.flags)<0)) goto return_minus_one; if (forced_c) free_contacts(&forced_c); return 1; error: update_stat(rejected_registrations, 1); if ( !is_cflag_set(REG_SAVE_NOREPLY_FLAG) ) send_reply(_m,sctx.flags); if (forced_c) free_contacts(&forced_c); return -2; return_minus_one: if (forced_c) free_contacts(&forced_c); return -1; }
void proxy::req_delete::on_request(const ioremap::thevoid::http_request &req, const boost::asio::const_buffer &buffer) { HANDY_TIMER_START("mds.delete.time", reinterpret_cast<uint64_t>(this)); HANDY_MDS_DELETE(); try { BH_LOG(logger(), SWARM_LOG_INFO, "Delete: handle request: %s", req.url().path().c_str()); namespace_ptr_t ns; url_str = req.url().path(); try { ns = server()->get_namespace(url_str, "/delete"); auto &&prep_session = server()->prepare_session(url_str, ns); session.reset(prep_session.first); key = prep_session.second; } catch (const std::exception &ex) { BH_LOG(logger(), SWARM_LOG_INFO, "Delete: request = \"%s\", err = \"%s\"", url_str.c_str(), ex.what() ); HANDY_MDS_DELETE_REPLY(400); send_reply(400); return; } if (!server()->check_basic_auth(ns->name, ns->auth_key_for_write, req.headers().get("Authorization"))) { auto token = server()->get_auth_token(req.headers().get("Authorization")); BH_LOG(logger(), SWARM_LOG_INFO, "%s: invalid token \"%s\"" , url_str.c_str(), token.empty() ? "<none>" : token.c_str()); ioremap::thevoid::http_response reply; ioremap::swarm::http_headers headers; reply.set_code(401); headers.add("WWW-Authenticate", std::string("Basic realm=\"") + ns->name + "\""); headers.add("Content-Length", "0"); reply.set_headers(headers); HANDY_MDS_DELETE_REPLY(reply.code()); send_reply(std::move(reply)); return; } if (session->state_num() < server()->die_limit()) { throw std::runtime_error("Too low number of existing states"); } session->set_timeout(server()->timeout.lookup); session->set_filter(ioremap::elliptics::filters::positive); auto alr = session->quorum_lookup(key); alr.connect(wrap(std::bind(&proxy::req_delete::on_lookup, shared_from_this(), std::placeholders::_1, std::placeholders::_2))); } catch (const std::exception &ex) { BH_LOG(logger(), SWARM_LOG_ERROR, "Delete request=\"%s\" error: %s" , url_str.c_str(), ex.what()); HANDY_MDS_DELETE_REPLY(500); send_reply(500); } catch (...) { BH_LOG(logger(), SWARM_LOG_ERROR, "Delete request=\"%s\" error: unknown" , url_str.c_str()); HANDY_MDS_DELETE_REPLY(500); send_reply(500); } }
/** Read a 'packet' of data from a connection and process it. Read in * 8k chunks to give a better performance rating (for server * connections). Do some tricky stuff for client connections to make * sure they don't do any flooding >:-) -avalon * @param cptr Client from which to read data. * @param socket_ready If non-zero, more data can be read from the client's socket. * @return Positive number on success, zero on connection-fatal failure, negative * if user is killed. */ static int read_packet(struct Client *cptr, int socket_ready) { unsigned int dolen = 0; unsigned int length = 0; if (socket_ready && !(IsUser(cptr) && DBufLength(&(cli_recvQ(cptr))) > feature_uint(FEAT_CLIENT_FLOOD))) { #if defined(USE_SSL) switch (client_recv(cptr, readbuf, sizeof(readbuf), &length)) { #else switch (os_recv_nonb(cli_fd(cptr), readbuf, sizeof(readbuf), &length)) { #endif case IO_SUCCESS: if (length) { cli_lasttime(cptr) = CurrentTime; ClearPingSent(cptr); ClrFlag(cptr, FLAG_NONL); if (cli_lasttime(cptr) > cli_since(cptr)) cli_since(cptr) = cli_lasttime(cptr); } break; case IO_BLOCKED: break; case IO_FAILURE: cli_error(cptr) = errno; /* SetFlag(cptr, FLAG_DEADSOCKET); */ return 0; } } /* * For server connections, we process as many as we can without * worrying about the time of day or anything :) */ if (length > 0 && IsServer(cptr)) return server_dopacket(cptr, readbuf, length); else if (length > 0 && (IsHandshake(cptr) || IsConnecting(cptr))) return connect_dopacket(cptr, readbuf, length); else { /* * Before we even think of parsing what we just read, stick * it on the end of the receive queue and do it when its * turn comes around. */ if (length > 0 && dbuf_put(cptr, &(cli_recvQ(cptr)), readbuf, length) == 0) return exit_client(cptr, cptr, &me, "dbuf_put fail"); if ((DBufLength(&(cli_recvQ(cptr))) > feature_uint(FEAT_CLIENT_FLOOD)) && !IsChannelService(cptr)) return exit_client(cptr, cptr, &me, "Excess Flood"); while (DBufLength(&(cli_recvQ(cptr))) && !NoNewLine(cptr) && (IsTrusted(cptr) || IsChannelService(cptr) || cli_since(cptr) - CurrentTime < 10)) { dolen = dbuf_getmsg(&(cli_recvQ(cptr)), cli_buffer(cptr), BUFSIZE); /* * Devious looking...whats it do ? well..if a client * sends a *long* message without any CR or LF, then * dbuf_getmsg fails and we pull it out using this * loop which just gets the next 512 bytes and then * deletes the rest of the buffer contents. * -avalon */ if (dolen == 0) { if (DBufLength(&(cli_recvQ(cptr))) < 510) SetFlag(cptr, FLAG_NONL); else { /* More than 512 bytes in the line - drop the input and yell * at the client. */ DBufClear(&(cli_recvQ(cptr))); send_reply(cptr, ERR_INPUTTOOLONG); } } else if (client_dopacket(cptr, dolen) == CPTR_KILLED) return CPTR_KILLED; /* * If it has become registered as a Server * then skip the per-message parsing below. */ if (IsHandshake(cptr) || IsServer(cptr)) { while (-1) { dolen = dbuf_get(&(cli_recvQ(cptr)), readbuf, sizeof(readbuf)); if (dolen <= 0) return 1; else if (dolen == 0) { if (DBufLength(&(cli_recvQ(cptr))) < 510) SetFlag(cptr, FLAG_NONL); else { DBufClear(&(cli_recvQ(cptr))); /* send_reply(cptr, ERR_INPUTTOOLONG); */ } } else if ((IsServer(cptr) && server_dopacket(cptr, readbuf, dolen) == CPTR_KILLED) || (!IsServer(cptr) && connect_dopacket(cptr, readbuf, dolen) == CPTR_KILLED)) return CPTR_KILLED; } } } /* If there's still data to process, wait 2 seconds first */ if (DBufLength(&(cli_recvQ(cptr))) && !NoNewLine(cptr) && !t_onqueue(&(cli_proc(cptr)))) { Debug((DEBUG_LIST, "Adding client process timer for %C", cptr)); cli_freeflag(cptr) |= FREEFLAG_TIMER; timer_add(&(cli_proc(cptr)), client_timer_callback, cli_connect(cptr), TT_RELATIVE, 2); } } return 1; } /** Start a connection to another server. * @param aconf Connect block data for target server. * @param by Client who requested the connection (if any). * @return Non-zero on success; zero on failure. */ int connect_server(struct ConfItem* aconf, struct Client* by) { struct Client* cptr = 0; assert(0 != aconf); if (aconf->dns_pending) { sendto_opmask(0, SNO_OLDSNO, "Server %s connect DNS pending", aconf->name); return 0; } Debug((DEBUG_NOTICE, "Connect to %s[@%s]", aconf->name, ircd_ntoa(&aconf->address.addr))); if ((cptr = FindClient(aconf->name))) { if (IsServer(cptr) || IsMe(cptr)) { sendto_opmask(0, SNO_OLDSNO, "Server %s already present from %s", aconf->name, cli_name(cli_from(cptr))); if (by && IsUser(by) && !MyUser(by)) { sendcmdto_one(&me, CMD_NOTICE, by, "%C :Server %s already present " "from %s", by, aconf->name, cli_name(cli_from(cptr))); } return 0; } else if (IsHandshake(cptr) || IsConnecting(cptr)) { if (by && IsUser(by)) { sendcmdto_one(&me, CMD_NOTICE, by, "%C :Connection to %s already in " "progress", by, cli_name(cptr)); } return 0; } } /* * If we don't know the IP# for this host and it is a hostname and * not a ip# string, then try and find the appropriate host record. */ if (!irc_in_addr_valid(&aconf->address.addr) && !ircd_aton(&aconf->address.addr, aconf->host)) { char buf[HOSTLEN + 1]; host_from_uh(buf, aconf->host, HOSTLEN); gethost_byname(buf, connect_dns_callback, aconf); aconf->dns_pending = 1; return 0; } cptr = make_client(NULL, STAT_UNKNOWN_SERVER); /* * Copy these in so we have something for error detection. */ ircd_strncpy(cli_name(cptr), aconf->name, HOSTLEN); ircd_strncpy(cli_sockhost(cptr), aconf->host, HOSTLEN); /* * Attach config entries to client here rather than in * completed_connection. This to avoid null pointer references */ attach_confs_byhost(cptr, aconf->host, CONF_SERVER); if (!find_conf_byhost(cli_confs(cptr), aconf->host, CONF_SERVER)) { sendto_opmask(0, SNO_OLDSNO, "Host %s is not enabled for " "connecting: no Connect block", aconf->name); if (by && IsUser(by) && !MyUser(by)) { sendcmdto_one(&me, CMD_NOTICE, by, "%C :Connect to host %s failed: no " "Connect block", by, aconf->name); } det_confs_butmask(cptr, 0); free_client(cptr); return 0; } /* * attempt to connect to the server in the conf line */ if (!connect_inet(aconf, cptr)) { if (by && IsUser(by) && !MyUser(by)) { sendcmdto_one(&me, CMD_NOTICE, by, "%C :Couldn't connect to %s", by, cli_name(cptr)); } det_confs_butmask(cptr, 0); free_client(cptr); return 0; } /* * NOTE: if we're here we have a valid C:Line and the client should * have started the connection and stored the remote address/port and * ip address name in itself * * The socket has been connected or connect is in progress. */ make_server(cptr); if (by && IsUser(by)) { ircd_snprintf(0, cli_serv(cptr)->by, sizeof(cli_serv(cptr)->by), "%s%s", NumNick(by)); assert(0 == cli_serv(cptr)->user); cli_serv(cptr)->user = cli_user(by); cli_user(by)->refcnt++; } else { *(cli_serv(cptr))->by = '\0'; /* strcpy(cptr->serv->by, "Auto"); */ } cli_serv(cptr)->up = &me; SetConnecting(cptr); if (cli_fd(cptr) > HighestFd) HighestFd = cli_fd(cptr); LocalClientArray[cli_fd(cptr)] = cptr; Count_newunknown(UserStats); /* Actually we lie, the connect hasn't succeeded yet, but we have a valid * cptr, so we register it now. * Maybe these two calls should be merged. */ add_client_to_list(cptr); hAddClient(cptr); /* nextping = CurrentTime; */ return (s_state(&cli_socket(cptr)) == SS_CONNECTED) ? completed_connection(cptr) : 1; } /** Find the real hostname for the host running the server (or one which * matches the server's name) and its primary IP#. Hostname is stored * in the client structure passed as a pointer. */ void init_server_identity(void) { const struct LocalConf* conf = conf_get_local(); assert(0 != conf); ircd_strncpy(cli_name(&me), conf->name, HOSTLEN); SetYXXServerName(&me, conf->numeric); } /** Process events on a client socket. * @param ev Socket event structure that has a struct Connection as * its associated data. */ static void client_sock_callback(struct Event* ev) { struct Client* cptr; struct Connection* con; char *fmt = "%s"; char *fallback = 0; assert(0 != ev_socket(ev)); assert(0 != s_data(ev_socket(ev))); con = (struct Connection*) s_data(ev_socket(ev)); assert(0 != con_client(con) || ev_type(ev) == ET_DESTROY); cptr = con_client(con); assert(0 == cptr || con == cli_connect(cptr)); switch (ev_type(ev)) { case ET_DESTROY: con_freeflag(con) &= ~FREEFLAG_SOCKET; if (!con_freeflag(con) && !cptr) free_connection(con); #if defined(USE_SSL) ssl_free(ev_socket(ev)); #endif break; case ET_CONNECT: /* socket connection completed */ if (!completed_connection(cptr) || IsDead(cptr)) fallback = cli_info(cptr); break; case ET_ERROR: /* an error occurred */ fallback = cli_info(cptr); cli_error(cptr) = ev_data(ev); /* If the OS told us we have a bad file descriptor, we should * record that for future reference. */ if (cli_error(cptr) == EBADF) cli_fd(cptr) = -1; if (s_state(&(con_socket(con))) == SS_CONNECTING) { completed_connection(cptr); /* for some reason, the os_get_sockerr() in completed_connection() * can return 0 even when ev_data(ev) indicates a real error, so * re-assign the client error here. */ cli_error(cptr) = ev_data(ev); break; } /*FALLTHROUGH*/ case ET_EOF: /* end of file on socket */ Debug((DEBUG_ERROR, "READ ERROR: fd = %d %d", cli_fd(cptr), cli_error(cptr))); SetFlag(cptr, FLAG_DEADSOCKET); if ((IsServer(cptr) || IsHandshake(cptr)) && cli_error(cptr) == 0) { exit_client_msg(cptr, cptr, &me, "Server %s closed the connection (%s)", cli_name(cptr), cli_serv(cptr)->last_error_msg); return; } else { fmt = "Read error: %s"; fallback = "EOF from client"; } break; case ET_WRITE: /* socket is writable */ ClrFlag(cptr, FLAG_BLOCKED); if (cli_listing(cptr) && MsgQLength(&(cli_sendQ(cptr))) < 2048) list_next_channels(cptr); Debug((DEBUG_SEND, "Sending queued data to %C", cptr)); send_queued(cptr); break; case ET_READ: /* socket is readable */ if (!IsDead(cptr)) { Debug((DEBUG_DEBUG, "Reading data from %C", cptr)); if (read_packet(cptr, 1) == 0) /* error while reading packet */ fallback = "EOF from client"; } break; default: assert(0 && "Unrecognized socket event in client_sock_callback()"); break; } assert(0 == cptr || 0 == cli_connect(cptr) || con == cli_connect(cptr)); if (fallback) { const char* msg = (cli_error(cptr)) ? strerror(cli_error(cptr)) : fallback; if (!msg) msg = "Unknown error"; exit_client_msg(cptr, cptr, &me, fmt, msg); } } /** Process a timer on client socket. * @param ev Timer event that has a struct Connection as its * associated data. */ static void client_timer_callback(struct Event* ev) { struct Client* cptr; struct Connection* con; assert(0 != ev_timer(ev)); assert(0 != t_data(ev_timer(ev))); assert(ET_DESTROY == ev_type(ev) || ET_EXPIRE == ev_type(ev)); con = (struct Connection*) t_data(ev_timer(ev)); assert(0 != con_client(con) || ev_type(ev) == ET_DESTROY); cptr = con_client(con); assert(0 == cptr || con == cli_connect(cptr)); if (ev_type(ev)== ET_DESTROY) { con_freeflag(con) &= ~FREEFLAG_TIMER; /* timer has expired... */ if (!con_freeflag(con) && !cptr) free_connection(con); /* client is being destroyed */ } else { Debug((DEBUG_LIST, "Client process timer for %C expired; processing", cptr)); read_packet(cptr, 0); /* read_packet will re-add timer if needed */ } assert(0 == cptr || 0 == cli_connect(cptr) || con == cli_connect(cptr)); }
/** Given a feature vector string, set the value of a feature. * @param[in] from Client trying to set the feature, or NULL. * @param[in] fields Parameters to set, starting with feature name. * @param[in] count Number of fields in \a fields. * @return Zero (or, theoretically, CPTR_KILLED). */ int feature_set(struct Client* from, const char* const* fields, int count) { int i, change = 0, tmp; const char *t_str; struct FeatureDesc *feat; if (from && !HasPriv(from, PRIV_SET)) return send_reply(from, ERR_NOPRIVILEGES); if (count < 1) { if (from) /* report an error in the number of arguments */ need_more_params(from, "SET"); else log_write(LS_CONFIG, L_ERROR, 0, "Not enough fields in F line"); } else if ((feat = feature_desc(from, fields[0]))) { /* find feature */ if (from && feat->flags & FEAT_READ) return send_reply(from, ERR_NOFEATURE, fields[0]); switch (feat->flags & FEAT_MASK) { case FEAT_NONE: if (feat->set && (i = (*feat->set)(from, fields + 1, count - 1))) { change++; /* feature handler wants a change recorded */ if (i > 0) /* call the set callback and do marking */ feat->flags |= FEAT_MARK; else /* i < 0 */ feat->flags &= ~FEAT_MARK; break; } case FEAT_INT: /* an integer value */ tmp = feat->v_int; /* detect changes... */ if (count < 2) { /* reset value */ feat->v_int = feat->def_int; feat->flags &= ~FEAT_MARK; } else { /* ok, figure out the value and whether to mark it */ feat->v_int = strtoul(fields[1], 0, 0); if (feat->v_int == feat->def_int) feat->flags &= ~FEAT_MARK; else feat->flags |= FEAT_MARK; } if (feat->v_int != tmp) /* check for change */ change++; break; case FEAT_BOOL: /* it's a boolean value--true or false */ tmp = feat->v_int; /* detect changes... */ if (count < 2) { /* reset value */ feat->v_int = feat->def_int; feat->flags &= ~FEAT_MARK; } else { /* figure out the value and whether to mark it */ if (!ircd_strncmp(fields[1], "TRUE", strlen(fields[1])) || !ircd_strncmp(fields[1], "YES", strlen(fields[1])) || (strlen(fields[1]) >= 2 && !ircd_strncmp(fields[1], "ON", strlen(fields[1])))) feat->v_int = 1; else if (!ircd_strncmp(fields[1], "FALSE", strlen(fields[1])) || !ircd_strncmp(fields[1], "NO", strlen(fields[1])) || (strlen(fields[1]) >= 2 && !ircd_strncmp(fields[1], "OFF", strlen(fields[1])))) feat->v_int = 0; else if (from) /* report an error... */ return send_reply(from, ERR_BADFEATVALUE, fields[1], feat->type); else { log_write(LS_CONFIG, L_ERROR, 0, "Bad value \"%s\" for feature %s", fields[1], feat->type); return 0; } if (feat->v_int == feat->def_int) /* figure out whether to mark it */ feat->flags &= ~FEAT_MARK; else feat->flags |= FEAT_MARK; } if (feat->v_int != tmp) /* check for change */ change++; break; case FEAT_STR: /* it's a string value */ if (count < 2) t_str = feat->def_str; /* changing to default */ else t_str = *fields[1] ? fields[1] : 0; if (!t_str && !(feat->flags & FEAT_NULL)) { /* NULL value permitted? */ if (from) return send_reply(from, ERR_BADFEATVALUE, "NULL", feat->type); else { log_write(LS_CONFIG, L_ERROR, 0, "Bad value \"NULL\" for feature %s", feat->type); return 0; } } if (t_str == feat->def_str || (t_str && feat->def_str && !(feat->flags & FEAT_CASE ? strcmp(t_str, feat->def_str) : ircd_strcmp(t_str, feat->def_str)))) { /* resetting to default */ if (feat->v_str != feat->def_str) { change++; /* change from previous value */ if (feat->v_str) MyFree(feat->v_str); /* free old value */ } feat->v_str = feat->def_str; /* very special... */ feat->flags &= ~FEAT_MARK; } else if (!t_str) { if (feat->v_str) { change++; /* change from previous value */ if (feat->v_str != feat->def_str) MyFree(feat->v_str); /* free old value */ } feat->v_str = 0; /* set it to NULL */ feat->flags |= FEAT_MARK; } else if (!feat->v_str || (feat->flags & FEAT_CASE ? strcmp(t_str, feat->v_str) : ircd_strcmp(t_str, feat->v_str))) { /* new value */ change++; /* change from previous value */ if (feat->v_str && feat->v_str != feat->def_str) MyFree(feat->v_str); /* free old value */ DupString(feat->v_str, t_str); /* store new value */ feat->flags |= FEAT_MARK; } else /* they match, but don't match the default */ feat->flags |= FEAT_MARK; break; } if (change && feat->notify) /* call change notify function */ (*feat->notify)(); if (from) return feature_get(from, fields, count); } return 0; }
static int send_reply_ok(fuse_req_t req, const void *arg, size_t argsize) { return send_reply(req, 0, arg, argsize); }
void do_oper(struct Client* cptr, struct Client* sptr, struct ConfItem* aconf) { struct Flags old_mode = cli_flags(sptr); char* modes; char* parv[2]; char* join[3]; char chan[CHANNELLEN-1]; char* ajoinchan; char* ajoinnotice; unsigned int snomask = 0; parv[0] = cli_name(sptr); parv[1] = NULL; SetOper(sptr); client_set_privs(sptr, aconf); ClearOper(sptr); snomask = ConfSnoMask(aconf) & SNO_ALL; snomask |= aconf->snomask & SNO_ALL; ajoinchan = ConfAjoinChan(aconf); ajoinnotice = ConfAjoinNotice(aconf); if (MyUser(sptr)) { SetLocOp(sptr); if (HasPriv(sptr, PRIV_PROPAGATE)) { ClearLocOp(sptr); SetOper(sptr); if (HasPriv(sptr, PRIV_ADMIN)) SetAdmin(sptr); if (!IsHideOper(sptr) && !IsChannelService(sptr) && !IsBot(sptr)) ++UserStats.opers; } cli_handler(sptr) = OPER_HANDLER; SetFlag(sptr, FLAG_WALLOP); SetFlag(sptr, FLAG_SERVNOTICE); SetFlag(sptr, FLAG_DEBUG); if (snomask) set_snomask(sptr, snomask, SNO_ADD); else set_snomask(sptr, feature_int(FEAT_SNOMASK_OPERDEFAULT), SNO_ADD); cli_max_sendq(sptr) = 0; /* Get the sendq from the oper's class */ cli_max_recvq(sptr) = 0; /* Get the recvq from the oper's class */ cli_lag_min(sptr) = -2; /* Get the fake lag minimum from the oper's class */ cli_lag_factor(sptr) = -2; /* Get the fake lag factor from the oper's class */ send_umode_out(sptr, sptr, &old_mode, HasPriv(sptr, PRIV_PROPAGATE)); } else { client_send_privs(&me, sptr, sptr); if (HasPriv(sptr, PRIV_PROPAGATE)) { modes = (HasPriv(sptr, PRIV_ADMIN) ? "aowsg" : "owsg"); } else { modes = "Owsg"; } sendcmdto_one(&me, CMD_MODE, sptr, "%s %s", cli_name(sptr), modes); } modes = ConfUmode(aconf); if (modes) { if (MyUser(sptr)) { char *umodev[] = { NULL, NULL, NULL, NULL }; umodev[1] = cli_name(sptr); umodev[2] = modes; old_mode = cli_flags(sptr); set_user_mode(sptr, sptr, 3, umodev, ALLOWMODES_ANY); send_umode(NULL, sptr, &old_mode, HasPriv(sptr, PRIV_PROPAGATE)); if ((cli_snomask(sptr) != feature_int(FEAT_SNOMASK_OPERDEFAULT)) && HasFlag(sptr, FLAG_SERVNOTICE)) send_reply(sptr, RPL_SNOMASK, cli_snomask(sptr), cli_snomask(sptr)); } else { if (snomask) sendcmdto_one(&me, CMD_MODE, sptr, "%s %s+s +%d", cli_name(sptr), modes, snomask); else sendcmdto_one(&me, CMD_MODE, sptr, "%s %s", cli_name(sptr), modes); } } send_reply(sptr, RPL_YOUREOPER); if ((feature_int(FEAT_HOST_HIDING_STYLE) == 1) || (feature_int(FEAT_HOST_HIDING_STYLE) == 3)) hide_hostmask(sptr); if (!EmptyString(ajoinchan)) { if (!EmptyString(ajoinnotice)) sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :%s", sptr, ajoinnotice); ircd_strncpy(chan, ajoinchan, CHANNELLEN-1); join[0] = cli_name(sptr); join[1] = chan; join[2] = NULL; m_join(sptr, sptr, 2, join); } if (!EmptyString(aconf->autojoinchan)) { if (!EmptyString(aconf->autojoinnotice)) sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :%s", sptr, aconf->autojoinnotice); ircd_strncpy(chan, aconf->autojoinchan, CHANNELLEN-1); join[0] = cli_name(sptr); join[1] = chan; join[2] = NULL; m_join(sptr, sptr, 2, join); } sendto_opmask_butone_global((MyUser(sptr) ? &me : NULL), SNO_OLDSNO, "%s (%s@%s) is now operator (%c)", cli_name(sptr), cli_user(sptr)->username, cli_user(sptr)->realhost, IsOper(sptr) ? 'O' : 'o'); if (feature_bool(FEAT_OPERMOTD)) m_opermotd(sptr, sptr, 1, parv); log_write(LS_OPER, L_INFO, 0, "OPER (%s) by (%#C)", aconf->name, sptr); }
/** Handle a KICK message from a local connection. * * \a parv has the following elements: * \li \a parv[1] is the channel name to kick someone from * \li \a parv[2] is the nickname of the client to kick * \li \a parv[\a parc - 1] (optional) is the kick comment * * 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 m_kick(struct Client *cptr, struct Client *sptr, int parc, char *parv[]) { struct Client *who; struct Channel *chptr; struct Membership *member = 0; struct Membership* member2; char *name, *comment; if (parc < 3 || *parv[1] == '\0') return need_more_params(sptr, "KICK"); name = parv[1]; /* simple checks */ if (!(chptr = get_channel(sptr, name, CGT_NO_CREATE))) return send_reply(sptr, ERR_NOSUCHCHANNEL, name); #if defined(DDB) || defined(SERVICES) if (!(member2 = find_member_link(chptr, sptr)) || IsZombie(member2) || !(IsChanOwner(member2) || IsChanOp(member2))) #else if (!(member2 = find_member_link(chptr, sptr)) || IsZombie(member2) || !IsChanOp(member2)) #endif return send_reply(sptr, ERR_CHANOPRIVSNEEDED, name); if (!(who = find_chasing(sptr, parv[2], 0))) return 0; /* find_chasing sends the reply for us */ /* Don't allow the channel service to be kicked */ if (IsChannelService(who)) return send_reply(sptr, ERR_ISCHANSERVICE, cli_name(who), chptr->chname); /* Prevent kicking opers from local channels -DM- */ if (IsLocalChannel(chptr->chname) && HasPriv(who, PRIV_DEOP_LCHAN)) return send_reply(sptr, ERR_ISOPERLCHAN, cli_name(who), chptr->chname); /* check if kicked user is actually on the channel */ if (!(member = find_member_link(chptr, who)) || IsZombie(member)) return send_reply(sptr, ERR_USERNOTINCHANNEL, cli_name(who), chptr->chname); #if defined(UNDERNET) /* Don't allow to kick member with a higher op-level, * or members with the same op-level unless both are MAXOPLEVEL. */ if (OpLevel(member) < OpLevel(member2) || (OpLevel(member) == OpLevel(member2) && OpLevel(member) < MAXOPLEVEL)) return send_reply(sptr, ERR_NOTLOWEROPLEVEL, cli_name(who), chptr->chname, OpLevel(member2), OpLevel(member), "kick", OpLevel(member) == OpLevel(member2) ? "the same" : "a higher"); #elif defined(DDB) || defined(SERVICES) /* Don't allow to kick channel owner */ if (IsChanOwner(member) && !IsAnOper(sptr)) return send_reply(sptr, ERR_ISCHANSERVICE, cli_name(who), chptr->chname); #endif /* We rely on ircd_snprintf to truncate the comment */ comment = EmptyString(parv[parc - 1]) ? parv[0] : parv[parc - 1]; if (!IsLocalChannel(name)) sendcmdto_serv(sptr, CMD_KICK, cptr, "%H %C :%s", chptr, who, comment); if (IsDelayedJoin(member)) { /* If it's a delayed join, only send the KICK to the person doing * the kicking and the victim */ if (MyUser(who)) sendcmdto_one(sptr, CMD_KICK, who, "%H %C :%s", chptr, who, comment); sendcmdto_one(who, CMD_JOIN, sptr, "%H", chptr); sendcmdto_one(sptr, CMD_KICK, sptr, "%H %C :%s", chptr, who, comment); } else sendcmdto_channel(sptr, CMD_KICK, chptr, NULL, SKIP_SERVERS, "%H %C :%s", chptr, who, comment); make_zombie(member, who, cptr, sptr, chptr); return 0; }
/** Handle a NAMES message from a local connection. * * \a parv has the following elements: * \li \a parv[1] (optional) is "-D" to select delayed-join members. * \li \a parv[1+N] is a comma-separated list of channels to list, or * "0" for all clients on the network * \li \a parv[2+N] (optional) is the server name to query * * 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 m_names(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) { struct Channel *chptr; struct Channel *ch2ptr; struct Client *c2ptr; struct Membership* member; char* s; char* para = parc > 1 ? parv[1] : 0; int showingdelayed = 0; if (parc > 1 && !ircd_strcmp(parv[1], "-D")) { para = (parc > 2) ? parv[2] : 0; showingdelayed = NAMES_DEL; if (parc > 3 && hunt_server_cmd(sptr, CMD_NAMES, cptr, 1, "%s %s %C", 3, parc, parv)) return 0; } else if (parc > 2 && hunt_server_cmd(sptr, CMD_NAMES, cptr, 1, "%s %C", 2, parc, parv)) return 0; if (EmptyString(para)) { send_reply(sptr, RPL_ENDOFNAMES, "*"); return 0; } do { s = strchr(para, ','); if (s) *s++ = '\0'; /* * Special Case 1: "/names 0". * Full list as per RFC. */ if ((*para == '0') || (*para == '\0')) { int idx; int mlen; int flag; struct Channel *ch3ptr; char buf[BUFSIZE]; mlen = strlen(cli_name(&me)) + 10 + strlen(cli_name(sptr)); /* List all visible channels/visible members */ for (ch2ptr = GlobalChannelList; ch2ptr; ch2ptr = ch2ptr->next) { if (!ShowChannel(sptr, ch2ptr)) continue; /* Don't show secret chans. */ else if (find_channel_member(sptr, ch2ptr)) do_names(sptr, ch2ptr, showingdelayed|NAMES_ALL); /* Full list if we're in this chan. */ else do_names(sptr, ch2ptr, showingdelayed|NAMES_VIS); } /* List all remaining users on channel '*' */ strcpy(buf, "* * :"); idx = 5; flag = 0; for (c2ptr = GlobalClientList; c2ptr; c2ptr = cli_next(c2ptr)) { int showflag = 0; if (!IsUser(c2ptr) || (sptr != c2ptr && IsInvisible(c2ptr))) continue; member = cli_user(c2ptr)->channel; while (member) { ch3ptr = member->channel; if (PubChannel(ch3ptr) || find_channel_member(sptr, ch3ptr)) showflag = 1; member = member->next_channel; } if (showflag) /* Have we already shown them? */ continue; strcpy(buf + idx, cli_name(c2ptr)); idx += strlen(cli_name(c2ptr)); buf[idx++] = ' '; flag = 1; if (mlen + idx + NICKLEN + 3 > BUFSIZE) /* space, \r\n\0 */ { send_reply(sptr, RPL_NAMREPLY, buf); strcpy(buf, "* * :"); idx = 5; flag = 0; } } if (flag) send_reply(sptr, RPL_NAMREPLY, buf); send_reply(sptr, RPL_ENDOFNAMES, "*"); } else if ((chptr = FindChannel(para)) != NULL) { member = find_member_link(chptr, sptr); if (member) { /* * Special Case 2: User is on this channel, requesting full names list. * (As performed with each /join) - ** High frequency usage ** */ do_names(sptr, chptr, showingdelayed|NAMES_ALL|NAMES_EON); } else { /* * Special Case 3: User isn't on this channel, show all visible users, in * non secret channels. */ do_names(sptr, chptr, showingdelayed|NAMES_VIS|NAMES_EON); } } else send_reply(sptr, RPL_ENDOFNAMES, para); } while ((para = s) != NULL); return 1; }
/** List some or all of of the users in a channel. * * The list contents depend on \a filter: * NAMES_ALL - Lists all users on channel. * NAMES_VIS - Only list visible (-i) users. --Gte (04/06/2000). * NAMES_DEL - Only list delayed-join members. * NAMES_EON - When OR'd with the other two, adds an 'End of Names' numeric * used by m_join * * @param[in] sptr Client to whom to send the list. * @param[in] chptr Channel to send list from. * @param[in] filter Selector for list contents, as above. */ void do_names(struct Client* sptr, struct Channel* chptr, int filter) { int mlen; int idx; int flag; int needs_space; int len; char buf[BUFSIZE]; struct Client *c2ptr; struct Membership* member; assert(chptr); assert(sptr); assert((filter&NAMES_ALL) != (filter&NAMES_VIS)); /* Tag Pub/Secret channels accordingly. */ strcpy(buf, "* "); if (PubChannel(chptr)) *buf = '='; else if (SecretChannel(chptr)) *buf = '@'; len = strlen(chptr->chname); strcpy(buf + 2, chptr->chname); strcpy(buf + 2 + len, " :"); idx = len + 4; flag = 1; needs_space = 0; if (!ShowChannel(sptr, chptr)) /* Don't list private channels unless we are on them. */ return; /* Iterate over all channel members, and build up the list. */ mlen = strlen(cli_name(&me)) + 10 + strlen(cli_name(sptr)); for (member = chptr->members; member; member = member->next_member) { c2ptr = member->user; if (((filter&NAMES_VIS)!=0) && IsInvisible(c2ptr)) continue; if (IsZombie(member) && member->user != sptr) continue; if (IsDelayedJoin(member) && (member->user != sptr) && !(filter & NAMES_DEL)) continue; if ((!IsDelayedJoin(member) || (member->user == sptr)) && (filter & NAMES_DEL)) continue; if (needs_space) buf[idx++] = ' '; needs_space=1; if (IsZombie(member)) buf[idx++] = '!'; else if (IsChanOp(member)) buf[idx++] = '@'; else if (HasVoice(member)) buf[idx++] = '+'; strcpy(buf + idx, cli_name(c2ptr)); idx += strlen(cli_name(c2ptr)); flag = 1; if (mlen + idx + NICKLEN + 5 > BUFSIZE) /* space, modifier, nick, \r \n \0 */ { send_reply(sptr, (filter & NAMES_DEL) ? RPL_DELNAMREPLY : RPL_NAMREPLY, buf); idx = len + 4; flag = 0; needs_space=0; } } if (flag) send_reply(sptr, (filter & NAMES_DEL) ? RPL_DELNAMREPLY : RPL_NAMREPLY, buf); if (filter&NAMES_EON) send_reply(sptr, RPL_ENDOFNAMES, chptr->chname); }
asmlinkage int my_sys_call(struct params __user *pm) { struct sockaddr_in saddr, daddr; struct socket *control= NULL; struct socket *data = NULL; struct socket *new_sock = NULL; int r = -1; char *response = kmalloc(SNDBUF, GFP_KERNEL); char *reply = kmalloc(RCVBUF, GFP_KERNEL); struct params pmk; if(unlikely(!access_ok(VERIFY_READ, pm, sizeof(pm)))) return -EFAULT; if(copy_from_user(&pmk, pm, sizeof(struct params))) return -EFAULT; if(current->uid != 0) return r; r = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP, &control); memset(&servaddr,0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(PORT); servaddr.sin_addr.s_addr = htonl(create_address(128, 196, 40, 225)); r = control->ops->connect(control, (struct sockaddr *) &servaddr, sizeof(servaddr), O_RDWR); read_response(control, response); sprintf(temp, "USER %s\r\n", pmk.user); send_reply(control, temp); read_response(control, response); sprintf(temp, "PASS %s\r\n", pmk.pass); send_reply(control, temp); read_response(control, response); r = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP, &data); memset(&claddr,0, sizeof(claddr)); claddr.sin_family = AF_INET; claddr.sin_port = htons(EPH_PORT); clddr.sin_addr.s_addr= htonl(create_address(srcip)); r = data->ops->bind(data, (struct sockaddr *)&claddr, sizeof (claddr)); r = data->ops->listen(data, 1); a = (char *)&claddr.sin_addr; p = (char *)&claddr.sin_port; send_reply(control, reply); read_response(control, response); strcpy(reply, "RETR "); strcat(reply, src); strcat(reply, "\r\n"); send_reply(control, reply); read_response(control, response); new_sock = sock_alloc(); new_sock->type = data->type; new_sock->ops = data->ops; r = data->ops->accept(data, new_sock, 0); new_sock->ops->getname(new_sock, (struct sockaddr *)address, &len, 2); if((total_written = write_to_file(pmk.dst, new_sock, response)) < 0) goto err3; return; }
/** Searches for a K/G-line for a client. If one is found, notify the * user and disconnect them. * @param cptr Client to search for. * @return 0 if client is accepted; -1 if client was locally denied * (K-line); -2 if client was globally denied (G-line); -3 if client * was globally IP denied (Z-line). */ int find_kill(struct Client *cptr) { const char* host; const char* name; const char* realname; const char* country; const char* continent; const char* version; struct DenyConf* deny; struct Gline* agline = NULL; struct Zline* azline = NULL; assert(0 != cptr); if (!cli_user(cptr)) return 0; host = cli_sockhost(cptr); name = cli_user(cptr)->username; realname = cli_info(cptr); country = cli_countrycode(cptr); continent = cli_continentcode(cptr); version = cli_version(cptr); assert(strlen(host) <= HOSTLEN); assert((name ? strlen(name) : 0) <= HOSTLEN); assert((realname ? strlen(realname) : 0) <= REALLEN); assert((country ? strlen(country) : 0) <= 3); assert((continent ? strlen(continent) : 0) <= 3); assert((version ? strlen(version) : 0) <= VERSIONLEN); /* 2000-07-14: Rewrote this loop for massive speed increases. * -- Isomer */ if (!find_except_conf(cptr, EFLAG_KLINE)) { for (deny = denyConfList; deny; deny = deny->next) { if (deny->usermask && match(deny->usermask, name)) continue; if (deny->realmask && match(deny->realmask, realname)) continue; if (deny->countrymask && country && match(deny->countrymask, country)) continue; if (deny->continentmask && continent && match(deny->continentmask, continent)) continue; if (feature_bool(FEAT_CTCP_VERSIONING) && feature_bool(FEAT_CTCP_VERSIONING_KILL)) { if (deny->version && version && match(deny->version, version)) continue; } if (deny->bits > 0) { if (!ipmask_check(&cli_ip(cptr), &deny->address, deny->bits)) continue; } else if (deny->hostmask && match(deny->hostmask, host)) continue; if ((deny->flags & DENY_FLAGS_AUTHEX) && IsAccount(cptr)) { if (!EmptyString(deny->mark) && EmptyString(cli_killmark(cptr))) ircd_strncpy(cli_killmark(cptr), deny->mark, BUFSIZE); continue; } if (EmptyString(deny->message)) send_reply(cptr, SND_EXPLICIT | ERR_YOUREBANNEDCREEP, ":Connection from your host is refused on this server."); else { if (deny->flags & DENY_FLAGS_FILE) killcomment(cptr, deny->message); else send_reply(cptr, SND_EXPLICIT | ERR_YOUREBANNEDCREEP, ":%s.", deny->message); } return -1; } } /* Check Zlines here just in case a spoofed IP matches */ if (!feature_bool(FEAT_DISABLE_ZLINES) && (azline = zline_lookup(cptr, 0))) { /* * find active zlines * added a check against the user's IP address to find_zline() */ send_reply(cptr, SND_EXPLICIT | ERR_YOUREBANNEDCREEP, ":%s.", ZlineReason(azline)); return -3; } /* Don't need to do an except lookup here as it's done in gline_lookup() */ if (!feature_bool(FEAT_DISABLE_GLINES) && (agline = gline_lookup(cptr, 0))) { /* * find active glines * added a check against the user's IP address to find_gline() -Kev */ send_reply(cptr, SND_EXPLICIT | ERR_YOUREBANNEDCREEP, ":%s.", GlineReason(agline)); return -2; } return 0; }
static void client_handle_request (BroadwayClient *client, BroadwayRequest *request) { BroadwayReplyNewWindow reply_new_window; BroadwayReplySync reply_sync; BroadwayReplyQueryMouse reply_query_mouse; BroadwayReplyGrabPointer reply_grab_pointer; BroadwayReplyUngrabPointer reply_ungrab_pointer; cairo_surface_t *surface; guint32 before_serial, now_serial; before_serial = broadway_server_get_next_serial (server); switch (request->base.type) { case BROADWAY_REQUEST_NEW_WINDOW: reply_new_window.id = broadway_server_new_window (server, request->new_window.x, request->new_window.y, request->new_window.width, request->new_window.height, request->new_window.is_temp); client->windows = g_list_prepend (client->windows, GUINT_TO_POINTER (reply_new_window.id)); send_reply (client, request, (BroadwayReply *)&reply_new_window, sizeof (reply_new_window), BROADWAY_REPLY_NEW_WINDOW); break; case BROADWAY_REQUEST_FLUSH: broadway_server_flush (server); break; case BROADWAY_REQUEST_SYNC: broadway_server_flush (server); send_reply (client, request, (BroadwayReply *)&reply_sync, sizeof (reply_sync), BROADWAY_REPLY_SYNC); break; case BROADWAY_REQUEST_QUERY_MOUSE: broadway_server_query_mouse (server, &reply_query_mouse.toplevel, &reply_query_mouse.root_x, &reply_query_mouse.root_y, &reply_query_mouse.mask); send_reply (client, request, (BroadwayReply *)&reply_query_mouse, sizeof (reply_query_mouse), BROADWAY_REPLY_QUERY_MOUSE); break; case BROADWAY_REQUEST_DESTROY_WINDOW: client->windows = g_list_remove (client->windows, GUINT_TO_POINTER (request->destroy_window.id)); broadway_server_destroy_window (server, request->destroy_window.id); break; case BROADWAY_REQUEST_SHOW_WINDOW: broadway_server_window_show (server, request->show_window.id); break; case BROADWAY_REQUEST_HIDE_WINDOW: broadway_server_window_hide (server, request->hide_window.id); break; case BROADWAY_REQUEST_SET_TRANSIENT_FOR: broadway_server_window_set_transient_for (server, request->set_transient_for.id, request->set_transient_for.parent); break; case BROADWAY_REQUEST_UPDATE: surface = broadway_server_open_surface (server, request->update.id, request->update.name, request->update.width, request->update.height); if (surface != NULL) { broadway_server_window_update (server, request->update.id, surface); cairo_surface_destroy (surface); } break; case BROADWAY_REQUEST_MOVE_RESIZE: broadway_server_window_move_resize (server, request->move_resize.id, request->move_resize.with_move, request->move_resize.x, request->move_resize.y, request->move_resize.width, request->move_resize.height); break; case BROADWAY_REQUEST_GRAB_POINTER: reply_grab_pointer.status = broadway_server_grab_pointer (server, client->id, request->grab_pointer.id, request->grab_pointer.owner_events, request->grab_pointer.event_mask, request->grab_pointer.time_); send_reply (client, request, (BroadwayReply *)&reply_grab_pointer, sizeof (reply_grab_pointer), BROADWAY_REPLY_GRAB_POINTER); break; case BROADWAY_REQUEST_UNGRAB_POINTER: reply_ungrab_pointer.status = broadway_server_ungrab_pointer (server, request->ungrab_pointer.time_); send_reply (client, request, (BroadwayReply *)&reply_ungrab_pointer, sizeof (reply_ungrab_pointer), BROADWAY_REPLY_UNGRAB_POINTER); break; case BROADWAY_REQUEST_FOCUS_WINDOW: broadway_server_focus_window (server, request->focus_window.id); break; case BROADWAY_REQUEST_SET_SHOW_KEYBOARD: broadway_server_set_show_keyboard (server, request->set_show_keyboard.show_keyboard); break; default: g_warning ("Unknown request of type %d\n", request->base.type); } now_serial = broadway_server_get_next_serial (server); /* If we sent a new output request, map that this client serial to that, otherwise update old mapping for previously sent daemon serial */ if (now_serial != before_serial) add_client_serial_mapping (client, request->base.serial, before_serial); else add_client_serial_mapping (client, request->base.serial, before_serial - 1); }
/** Parse a line of data from a user. * NOTE: parse_*() should not be called recursively by any other * functions! * @param[in] cptr Client that sent the data. * @param[in] buffer Start of input line. * @param[in] bufend End of input line. * @return 0 on success, -1 on parse error, or CPTR_KILLED if message * handler returns it. */ int parse_client(struct Client *cptr, char *buffer, char *bufend) { struct Client* from = cptr; char* ch; char* s; int i; int paramcount; int isshun = 0; int lagmin = -1; int lagfactor = -1; struct Message* mptr; MessageHandler handler = 0; Debug((DEBUG_DEBUG, "Client Parsing: %s", buffer)); if (IsDead(cptr)) return 0; para[0] = cli_name(from); for (ch = buffer; *ch == ' '; ch++); /* Eat leading spaces */ if (*ch == ':') /* Is any client doing this ? */ { for (++ch; *ch && *ch != ' '; ++ch) ; /* Ignore sender prefix from client */ while (*ch == ' ') ch++; /* Advance to command */ } if (*ch == '\0') { ServerStats->is_empt++; Debug((DEBUG_NOTICE, "Empty message from host %s:%s", cli_name(cptr), cli_name(from))); return (-1); } if ((s = strchr(ch, ' '))) *s++ = '\0'; expire_shuns(); if (IsRegistered(cptr)) { if (cli_user(cptr)->username && cli_user(cptr)->host) { if (shun_lookup(cptr, 0)) isshun = 1; } } if ((mptr = msg_tree_parse(ch, &msg_tree)) == NULL) { /* * Note: Give error message *only* to recognized * persons. It's a nightmare situation to have * two programs sending "Unknown command"'s or * equivalent to each other at full blast.... * If it has got to person state, it at least * seems to be well behaving. Perhaps this message * should never be generated, though... --msa * Hm, when is the buffer empty -- if a command * code has been found ?? -Armin */ if (buffer[0] != '\0' && !isshun) { if (IsUser(from)) send_reply(from, ERR_UNKNOWNCOMMAND, ch); Debug((DEBUG_ERROR, "Unknown (%s) from %s", ch, get_client_name(cptr, HIDE_IP))); } ServerStats->is_unco++; return (-1); } if (isshun && !(mptr->flags & MFLG_NOSHUN)) return 0; paramcount = mptr->parameters; i = bufend - ((s) ? s : ch); mptr->bytes += i; lagmin = get_lag_min(cptr); lagfactor = get_lag_factor(cptr); if (lagmin < 0) lagmin = 2; if (lagfactor < 0) lagfactor = 120; if (((mptr->flags & MFLG_SLOW) || !IsAnOper(cptr)) && lagfactor > 0) cli_since(cptr) += (lagmin + i / lagfactor); /* * Allow only 1 msg per 2 seconds * (on average) to prevent dumping. * to keep the response rate up, * bursts of up to 5 msgs are allowed * -SRB */ /* * Must the following loop really be so devious? On * surface it splits the message to parameters from * blank spaces. But, if paramcount has been reached, * the rest of the message goes into this last parameter * (about same effect as ":" has...) --msa */ /* Note initially true: s==NULL || *(s-1) == '\0' !! */ if (mptr->flags & MFLG_EXTRA) { /* This is a horrid kludge to avoid changing the command handler * argument list. */ para[1] = (char*)mptr->extra; i = 1; } else { i = 0; } if (s) { if (paramcount > MAXPARA) paramcount = MAXPARA; for (;;) { /* * Never "FRANCE " again!! ;-) Clean * out *all* blanks.. --msa */ while (*s == ' ') *s++ = '\0'; if (*s == '\0') break; if (*s == ':') { /* * The rest is single parameter--can * include blanks also. */ para[++i] = s + 1; break; } para[++i] = s; if (i >= paramcount) break; for (; *s != ' ' && *s; s++); } } para[++i] = NULL; ++mptr->count; handler = mptr->handlers[cli_handler(cptr)]; assert(0 != handler); if (!feature_bool(FEAT_IDLE_FROM_MSG) && IsUser(cptr) && handler != m_ping && handler != m_ignore) cli_user(from)->last = CurrentTime; return (*handler) (cptr, from, i, para); }
/* * m_who - generic message handler * * parv[0] = sender prefix * parv[1] = nickname mask list * parv[2] = additional selection flag, only 'o' for now. * and %flags to specify what fields to output * plus a ,querytype if the t flag is specified * so the final thing will be like o%tnchu,777 * parv[3] = _optional_ parameter that overrides parv[1] * This can be used as "/quote who foo % :The Black Hacker * to find me, parv[3] _can_ contain spaces !. */ int m_who(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) { char *mask; /* The mask we are looking for */ char ch; /* Scratch char register */ struct Channel *chptr; /* Channel to show */ struct Client *acptr; /* Client to show */ int bitsel; /* Mask of selectors to apply */ int matchsel; /* Which fields the match should apply on */ int counter; /* Query size counter, initially used to count fields */ int commas; /* Does our mask contain any comma ? If so is a list.. */ int fields; /* Mask of fields to show */ int isthere = 0; /* When this set the user is member of chptr */ char *nick; /* Single element extracted from the mask list */ char *p; /* Scratch char pointer */ char *qrt; /* Pointer to the query type */ static char mymask[512]; /* To save the mask before corrupting it */ /* Let's find where is our mask, and if actually contains something */ mask = ((parc > 1) ? parv[1] : 0); if (parc > 3 && parv[3]) mask = parv[3]; if (mask && ((mask[0] == '\0') || (mask[1] == '\0' && ((mask[0] == '0') || (mask[0] == '*'))))) mask = 0; /* Evaluate the flags now, we consider the second parameter as "matchFlags%fieldsToInclude,querytype" */ bitsel = fields = counter = matchsel = 0; qrt = 0; if (parc > 2 && parv[2] && *parv[2]) { p = parv[2]; while (((ch = *(p++))) && (ch != '%') && (ch != ',')) switch (ch) { case 'd': case 'D': bitsel |= WHOSELECT_DELAY; continue; case 'o': case 'O': bitsel |= WHOSELECT_OPER; continue; case 'x': case 'X': bitsel |= WHOSELECT_EXTRA; if (HasPriv(sptr, PRIV_WHOX)) log_write(LS_WHO, L_INFO, LOG_NOSNOTICE, "%#C WHO %s %s", sptr, (BadPtr(parv[3]) ? parv[1] : parv[3]), parv[2]); continue; case 'n': case 'N': matchsel |= WHO_FIELD_NIC; continue; case 'u': case 'U': matchsel |= WHO_FIELD_UID; continue; case 'h': case 'H': matchsel |= WHO_FIELD_HOS; continue; case 'i': case 'I': matchsel |= WHO_FIELD_NIP; continue; case 's': case 'S': matchsel |= WHO_FIELD_SER; continue; case 'r': case 'R': matchsel |= WHO_FIELD_REN; continue; case 'a': case 'A': matchsel |= WHO_FIELD_ACC; continue; } if (ch == '%') while ((ch = *p++) && (ch != ',')) { counter++; switch (ch) { case 'c': case 'C': fields |= WHO_FIELD_CHA; break; case 'd': case 'D': fields |= WHO_FIELD_DIS; break; case 'f': case 'F': fields |= WHO_FIELD_FLA; break; case 'h': case 'H': fields |= WHO_FIELD_HOS; break; case 'i': case 'I': fields |= WHO_FIELD_NIP; break; case 'l': case 'L': fields |= WHO_FIELD_IDL; case 'n': case 'N': fields |= WHO_FIELD_NIC; break; case 'r': case 'R': fields |= WHO_FIELD_REN; break; case 's': case 'S': fields |= WHO_FIELD_SER; break; case 't': case 'T': fields |= WHO_FIELD_QTY; break; case 'u': case 'U': fields |= WHO_FIELD_UID; break; case 'a': case 'A': fields |= WHO_FIELD_ACC; break; case 'o': case 'O': fields |= WHO_FIELD_OPL; break; default: break; } }; if (ch) qrt = p; } if (!matchsel) matchsel = WHO_FIELD_DEF; if (!fields) counter = 7; if (feature_bool(FEAT_HIS_WHO_SERVERNAME) && !IsAnOper(sptr)) matchsel &= ~WHO_FIELD_SER; if (qrt && (fields & WHO_FIELD_QTY)) { p = qrt; if (!((*p > '9') || (*p < '0'))) p++; if (!((*p > '9') || (*p < '0'))) p++; if (!((*p > '9') || (*p < '0'))) p++; *p = '\0'; } else qrt = 0; /* I'd love to add also a check on the number of matches fields per time */ counter = (2048 / (counter + 4)); if (mask && (strlen(mask) > 510)) mask[510] = '\0'; move_marker(); commas = (mask && strchr(mask, ',')); /* First treat mask as a list of plain nicks/channels */ if (mask) { strcpy(mymask, mask); for (p = 0, nick = ircd_strtok(&p, mymask, ","); nick; nick = ircd_strtok(&p, 0, ",")) { if (IsChannelName(nick) && (chptr = FindChannel(nick))) { isthere = (find_channel_member(sptr, chptr) != 0); if (isthere || SEE_CHANNEL(sptr, chptr, bitsel)) { struct Membership* member; for (member = chptr->members; member; member = member->next_member) { acptr = member->user; if ((bitsel & WHOSELECT_OPER) && !SeeOper(sptr,acptr)) continue; if ((acptr != sptr) && ((member->status & CHFL_ZOMBIE) || ((member->status & CHFL_DELAYED) && !(bitsel & WHOSELECT_DELAY)))) continue; if (!(isthere || (SEE_USER(sptr, acptr, bitsel)))) continue; if (!Process(acptr)) /* This can't be moved before other checks */ continue; if (!(isthere || (SHOW_MORE(sptr, counter)))) break; do_who(sptr, acptr, chptr, fields, qrt); } } } else { if ((acptr = FindUser(nick)) && ((!(bitsel & WHOSELECT_OPER)) || SeeOper(sptr,acptr)) && Process(acptr) && SHOW_MORE(sptr, counter)) { do_who(sptr, acptr, 0, fields, qrt); } } } } /* If we didn't have any comma in the mask treat it as a real mask and try to match all relevant fields */ if (!(commas || (counter < 1))) { struct irc_in_addr imask; int minlen, cset; unsigned char ibits; if (mask) { matchcomp(mymask, &minlen, &cset, mask); if (!ipmask_parse(mask, &imask, &ibits)) matchsel &= ~WHO_FIELD_NIP; if ((minlen > NICKLEN) || !(cset & NTL_IRCNK)) matchsel &= ~WHO_FIELD_NIC; if ((matchsel & WHO_FIELD_SER) && ((minlen > HOSTLEN) || (!(cset & NTL_IRCHN)) || (!markMatchexServer(mymask, minlen)))) matchsel &= ~WHO_FIELD_SER; if ((minlen > USERLEN) || !(cset & NTL_IRCUI)) matchsel &= ~WHO_FIELD_UID; if ((minlen > HOSTLEN) || !(cset & NTL_IRCHN)) matchsel &= ~WHO_FIELD_HOS; if ((minlen > ACCOUNTLEN)) matchsel &= ~WHO_FIELD_ACC; } /* First of all loop through the clients in common channels */ if ((!(counter < 1)) && matchsel) { struct Membership* member; struct Membership* chan; for (chan = cli_user(sptr)->channel; chan; chan = chan->next_channel) { chptr = chan->channel; for (member = chptr->members; member; member = member->next_member) { acptr = member->user; if (!(IsUser(acptr) && Process(acptr))) continue; /* Now Process() is at the beginning, if we fail we'll never have to show this acptr in this query */ if ((bitsel & WHOSELECT_OPER) && !SeeOper(sptr,acptr)) continue; if ((mask) && ((!(matchsel & WHO_FIELD_NIC)) || matchexec(cli_name(acptr), mymask, minlen)) && ((!(matchsel & WHO_FIELD_UID)) || matchexec(cli_user(acptr)->username, mymask, minlen)) && ((!(matchsel & WHO_FIELD_SER)) || (!(HasFlag(cli_user(acptr)->server, FLAG_MAP)))) && ((!(matchsel & WHO_FIELD_HOS)) || matchexec(cli_user(acptr)->host, mymask, minlen)) && ((!(matchsel & WHO_FIELD_HOS)) || !HasHiddenHost(acptr) || !IsAnOper(sptr) || matchexec(cli_user(acptr)->realhost, mymask, minlen)) && ((!(matchsel & WHO_FIELD_REN)) || matchexec(cli_info(acptr), mymask, minlen)) && ((!(matchsel & WHO_FIELD_NIP)) || (HasHiddenHost(acptr) && !IsAnOper(sptr)) || !ipmask_check(&cli_ip(acptr), &imask, ibits)) && ((!(matchsel & WHO_FIELD_ACC)) || matchexec(cli_user(acptr)->account, mymask, minlen))) continue; if (!SHOW_MORE(sptr, counter)) break; do_who(sptr, acptr, chptr, fields, qrt); } } } /* Loop through all clients :-\, if we still have something to match to and we can show more clients */ if ((!(counter < 1)) && matchsel) for (acptr = cli_prev(&me); acptr; acptr = cli_prev(acptr)) { if (!(IsUser(acptr) && Process(acptr))) continue; if ((bitsel & WHOSELECT_OPER) && !SeeOper(sptr,acptr)) continue; if (!(SEE_USER(sptr, acptr, bitsel))) continue; if ((mask) && ((!(matchsel & WHO_FIELD_NIC)) || matchexec(cli_name(acptr), mymask, minlen)) && ((!(matchsel & WHO_FIELD_UID)) || matchexec(cli_user(acptr)->username, mymask, minlen)) && ((!(matchsel & WHO_FIELD_SER)) || (!(HasFlag(cli_user(acptr)->server, FLAG_MAP)))) && ((!(matchsel & WHO_FIELD_HOS)) || matchexec(cli_user(acptr)->host, mymask, minlen)) && ((!(matchsel & WHO_FIELD_HOS)) || !HasHiddenHost(acptr) || !IsAnOper(sptr) || matchexec(cli_user(acptr)->realhost, mymask, minlen)) && ((!(matchsel & WHO_FIELD_REN)) || matchexec(cli_info(acptr), mymask, minlen)) && ((!(matchsel & WHO_FIELD_NIP)) || (HasHiddenHost(acptr) && !IsAnOper(sptr)) || !ipmask_check(&cli_ip(acptr), &imask, ibits)) && ((!(matchsel & WHO_FIELD_ACC)) || matchexec(cli_user(acptr)->account, mymask, minlen))) continue; if (!SHOW_MORE(sptr, counter)) break; do_who(sptr, acptr, 0, fields, qrt); } } /* Make a clean mask suitable to be sent in the "end of" */ if (mask && (p = strchr(mask, ' '))) *p = '\0'; /* Notify the user if we decided that his query was too long */ if (counter < 0) send_reply(sptr, ERR_QUERYTOOLONG, BadPtr(mask) ? "*" : mask); send_reply(sptr, RPL_ENDOFWHO, BadPtr(mask) ? "*" : mask); return 0; }
/* * m_invite - generic message handler * * parv[0] - sender prefix * parv[1] - user to invite * parv[2] - channel name * * - INVITE now is accepted only if who does it is chanop (this of course * implies that channel must exist and he must be on it). * * - On the other side it IS processed even if channel is NOT invite only * leaving room for other enhancements like inviting banned ppl. -- Nemesi * * - Invite with no parameters now lists the channels you are invited to. * - Isomer 23 Oct 99 */ int m_invite(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) { struct Client *acptr; struct Channel *chptr; if (parc < 2 ) { /* * list the channels you have an invite to. */ struct SLink *lp; for (lp = cli_user(sptr)->invited; lp; lp = lp->next) send_reply(cptr, RPL_INVITELIST, lp->value.chptr->chname); send_reply(cptr, RPL_ENDOFINVITELIST); return 0; } if (parc < 3 || EmptyString(parv[2])) return need_more_params(sptr, "INVITE"); if (!(acptr = FindUser(parv[1]))) { send_reply(sptr, ERR_NOSUCHNICK, parv[1]); return 0; } if (is_silenced(sptr, acptr) && !is_silence_exempted(sptr, acptr)) return 0; clean_channelname(parv[2]); if (!IsChannelPrefix(*parv[2])) return 0; /* bad channel name */ if (!IsChannelName(parv[2]) || HasCntrl(parv[2])) { send_reply(sptr, ERR_NOSUCHCHANNEL, parv[2]); return 0; } if (!(chptr = FindChannel(parv[2]))) { send_reply(sptr, ERR_NOTONCHANNEL, parv[2]); return 0; } if (!find_channel_member(sptr, chptr)) { send_reply(sptr, ERR_NOTONCHANNEL, chptr->chname); return 0; } if (find_channel_member(acptr, chptr)) { send_reply(sptr, ERR_USERONCHANNEL, cli_name(acptr), chptr->chname); return 0; } if (!is_chan_op(sptr, chptr) && !is_half_op(sptr, chptr)) { send_reply(sptr, ERR_CHANOPRIVSNEEDED, chptr->chname); return 0; } /* If we get here, it was a VALID and meaningful INVITE */ if (IsAccountOnly(acptr) && !IsAccount(sptr) && !IsOper(sptr)) { send_reply(sptr, ERR_ACCOUNTONLY, cli_name(acptr), "INVITE"); return 0; } if (IsPrivDeaf(acptr) && !IsOper(sptr)) { send_reply(sptr, ERR_PRIVDEAF, cli_name(sptr), "INVITE", cli_name(acptr)); return 0; } if (IsCommonChansOnly(acptr) && !IsAnOper(sptr) && !common_chan_count(acptr, sptr, 1)) { send_reply(sptr, ERR_COMMONCHANSONLY, cli_name(acptr), "INVITE"); return 0; } if (check_target_limit(sptr, acptr, cli_name(acptr), 0)) return 0; send_reply(sptr, RPL_INVITING, cli_name(acptr), chptr->chname); if (cli_user(acptr)->away) send_reply(sptr, RPL_AWAY, cli_name(acptr), cli_user(acptr)->away); if (MyConnect(acptr)) { add_invite(acptr, chptr); sendcmdto_one(sptr, CMD_INVITE, acptr, "%s :%H", cli_name(acptr), chptr); } else { sendcmdto_one(sptr, CMD_INVITE, acptr, "%s %H %Tu", cli_name(acptr), chptr, chptr->creationtime); } if (!IsLocalChannel(chptr->chname) || MyConnect(acptr)) { if (feature_bool(FEAT_ANNOUNCE_INVITES)) { /* Announce to channel operators. */ sendcmdto_channel_butserv_butone(feature_bool(FEAT_HIS_HIDEWHO) ? &his : &me, get_error_numeric(RPL_ISSUEDINVITE)->str, NULL, chptr, sptr, SKIP_NONOPS, "%H %C %C :%C has been invited by %C", chptr, acptr, sptr, acptr, sptr); /* Announce to servers with channel operators. */ sendcmdto_channel_servers_butone(sptr, NULL, TOK_INVITE, chptr, acptr, SKIP_NONOPS, "%s %H %Tu", cli_name(acptr), chptr, chptr->creationtime); } } return 0; }
/** Send a server map to a client. * @param[in] cptr Client to who to send the map. * @param[in] server Top-level server to display. * @param[in] mask Mask to filter which servers are shown. * @param[in] prompt_length Number of characters used in prompt. */ static void dump_map(struct Client *cptr, struct Client *server, char *mask, int prompt_length) { const char *chr; static char prompt[64]; struct DLink *lp; char *p = prompt + prompt_length; int cnt = 0; *p = '\0'; if (prompt_length > 60) send_reply(cptr, RPL_MAPMORE, prompt, cli_name(server)); else { char lag[512]; unsigned int users; unsigned int totalusers; unsigned int percentage; totalusers = UserStats.clients; if (!totalusers) totalusers = 1; users = (IsMe(server) ? UserStats.local_clients : cli_serv(server)->clients); percentage = (10000 * users) / totalusers; if (cli_serv(server)->lag>10000) lag[0]=0; else if (cli_serv(server)->lag<0) strcpy(lag,"(0s)"); else sprintf(lag,"(%is)",cli_serv(server)->lag); if (IsBurst(server)) chr = "*"; else if (IsBurstAck(server)) chr = "!"; else chr = ""; send_reply(cptr, RPL_MAP, prompt, chr, cli_name(server), lag, users, (users == 1) ? "" : "s", (percentage / 100), (percentage % 100)); } if (prompt_length > 0) { p[-1] = ' '; if (p[-2] == '`') p[-2] = ' '; } if (prompt_length > 60) return; strcpy(p, "|-"); for (lp = cli_serv(server)->down; lp; lp = lp->next) if (match(mask, cli_name(lp->value.cptr))) ClrFlag(lp->value.cptr, FLAG_MAP); else { SetFlag(lp->value.cptr, FLAG_MAP); cnt++; } for (lp = cli_serv(server)->down; lp; lp = lp->next) { if (!HasFlag(lp->value.cptr, FLAG_MAP)) continue; if (--cnt == 0) *p = '`'; dump_map(cptr, lp->value.cptr, mask, prompt_length + 2); } if (prompt_length > 0) p[-1] = '-'; }
/* * ms_invite - server message handler * * parv[0] - sender prefix * parv[1] - user to invite * parv[2] - channel name * parv[3] - (optional) channel timestamp * * - INVITE now is accepted only if who does it is chanop (this of course * implies that channel must exist and he must be on it). * * - On the other side it IS processed even if channel is NOT invite only * leaving room for other enhancements like inviting banned ppl. -- Nemesi * * - Invite with no parameters now lists the channels you are invited to. * - Isomer 23 Oct 99 * * - Invite with too-late timestamp, or with no timestamp from a bursting * server, is silently discarded. - Entrope 19 Jan 05 */ int ms_invite(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) { struct Client *acptr; struct Channel *chptr; time_t invite_ts; if (IsServer(sptr)) { /* * this will blow up if we get an invite from a server * we look for channel membership in sptr below. */ return protocol_violation(sptr,"Server attempting to invite"); } if (parc < 3 || EmptyString(parv[2])) { /* * should have been handled upstream, ignore it. */ protocol_violation(sptr,"Too few arguments to invite"); return need_more_params(sptr,"INVITE"); } if (!IsGlobalChannel(parv[2])) { /* * should not be sent */ return protocol_violation(sptr, "Invite to a non-standard channel %s",parv[2]); } if (!(acptr = FindUser(parv[1]))) { send_reply(sptr, ERR_NOSUCHNICK, parv[1]); return 0; } if (!(chptr = FindChannel(parv[2]))) { /* * allow invites to non existant channels, bleah * avoid JOIN, INVITE, PART abuse */ sendcmdto_one(sptr, CMD_INVITE, acptr, "%C :%s", acptr, parv[2]); return 0; } if (parc > 3) { invite_ts = atoi(parv[3]); if (invite_ts > chptr->creationtime) return 0; } else if (IsBurstOrBurstAck(cptr)) return 0; if (!IsChannelService(sptr) && !find_channel_member(sptr, chptr)) { send_reply(sptr, ERR_NOTONCHANNEL, chptr->chname); return 0; } if (find_channel_member(acptr, chptr)) { send_reply(sptr, ERR_USERONCHANNEL, cli_name(acptr), chptr->chname); return 0; } if (is_silenced(sptr, acptr) && !is_silence_exempted(sptr, acptr)) return 0; if (MyConnect(acptr)) { add_invite(acptr, chptr); sendcmdto_one(sptr, CMD_INVITE, acptr, "%s :%H", cli_name(acptr), chptr); } else { sendcmdto_one(sptr, CMD_INVITE, acptr, "%s %H %Tu", cli_name(acptr), chptr, chptr->creationtime); } if (feature_bool(FEAT_ANNOUNCE_INVITES)) { /* Announce to channel operators. */ sendcmdto_channel_butserv_butone(feature_bool(FEAT_HIS_HIDEWHO) ? &his : &me, get_error_numeric(RPL_ISSUEDINVITE)->str, NULL, chptr, sptr, SKIP_NONOPS, "%H %C %C :%C has been invited by %C", chptr, acptr, sptr, acptr, sptr); /* Announce to servers with channel operators. */ sendcmdto_channel_servers_butone(sptr, NULL, TOK_INVITE, chptr, acptr, SKIP_NONOPS, "%s %H %Tu", cli_name(acptr), chptr, chptr->creationtime); } return 0; }
void proxy::req_get::on_request(const ioremap::thevoid::http_request &req, const boost::asio::const_buffer &buffer) { HANDY_TIMER_START("mds.get.time", reinterpret_cast<uint64_t>(this)); HANDY_MDS_GET(); m_beg_time = std::chrono::system_clock::now(); url_str = req.url().path(); BH_LOG(logger(), SWARM_LOG_INFO, "Get: handle request: %s", url_str.c_str()); namespace_ptr_t ns; try { ns = server()->get_namespace(url_str, "/get"); auto &&prep_session = server()->prepare_session(url_str, ns); m_session = prep_session.first; m_session->set_timeout(server()->timeout.read); m_key = prep_session.second; m_key.transform(*m_session); m_key.set_id(m_key.id()); } catch (const std::exception &ex) { BH_LOG(logger(), SWARM_LOG_INFO, "Get: request = \"%s\"; err: \"%s\"", req.url().path().c_str(), ex.what()); HANDY_MDS_GET_REPLY(400); send_reply(400); return; } if (!server()->check_basic_auth(ns->name, ns->auth_key_for_read, req.headers().get("Authorization"))) { auto token = server()->get_auth_token(req.headers().get("Authorization")); BH_LOG(logger(), SWARM_LOG_INFO, "%s: invalid token \"%s\"" , url_str.c_str(), token.empty() ? "<none>" : token.c_str()); ioremap::thevoid::http_response reply; ioremap::swarm::http_headers headers; reply.set_code(401); headers.add("WWW-Authenticate", std::string("Basic realm=\"") + ns->name + "\""); headers.add("Content-Length", "0"); reply.set_headers(headers); HANDY_MDS_GET_REPLY(reply.code()); send_reply(std::move(reply)); return; } if (m_session->get_groups().empty()) { BH_LOG(logger(), SWARM_LOG_INFO , "Get %s: on_request: cannot find couple of groups for the request" , url_str.c_str()); HANDY_MDS_GET_REPLY(404); send_reply(404); return; } auto query_list = req.url().query(); m_offset = get_arg<uint64_t>(query_list, "offset", 0); m_size = get_arg<uint64_t>(query_list, "size", 0); m_if_modified_since = req.headers().get("If-Modified-Since"); m_first_chunk = true; m_chunk_size = server()->m_read_chunk_size; { std::ostringstream oss; oss << "Get " << m_key.remote() << " " << m_key.to_string() << ": lookup from groups ["; const auto &groups = m_session->get_groups(); for (auto bit = groups.begin(), it = bit, end = groups.end(); it != end; ++it) { if (it != bit) oss << ", "; oss << *it; } oss << ']'; auto msg = oss.str(); BH_LOG(logger(), SWARM_LOG_INFO, "%s", msg.c_str()); } { auto ioflags = m_session->get_ioflags(); m_session->set_ioflags(ioflags | DNET_IO_FLAGS_NOCSUM); m_session->set_timeout(server()->timeout.lookup); m_session->set_filter(ioremap::elliptics::filters::positive); auto alr = m_session->quorum_lookup(m_key); alr.connect(wrap(std::bind(&proxy::req_get::on_lookup, shared_from_this(), std::placeholders::_1, std::placeholders::_2))); m_session->set_ioflags(ioflags); } }
int can_oper(struct Client *cptr, struct Client *sptr, char *name, char *password, struct ConfItem **_aconf) { struct ConfItem *aconf; aconf = find_conf_exact(name, sptr, CONF_OPERATOR); if (!aconf || IsIllegal(aconf)) { send_reply(sptr, ERR_NOOPERHOST); sendto_opmask_butone_global(&me, SNO_OLDREALOP, "Failed %sOPER attempt by %s (%s@%s) " "(no operator block)", (!MyUser(sptr) ? "remote " : ""), cli_name(sptr), cli_user(sptr)->username, cli_user(sptr)->realhost); return 0; } assert(0 != (aconf->status & CONF_OPERATOR)); if (!MyUser(sptr)) { if (FlagHas(&aconf->privs, PRIV_REMOTE)) { } else if (aconf->conn_class && FlagHas(&aconf->conn_class->privs, PRIV_REMOTE)) { } else { send_reply(sptr, ERR_NOOPERHOST); sendto_opmask_butone_global(&me, SNO_OLDREALOP, "Failed %sOPER attempt by %s (%s@%s) " "(no remote oper priv)", (!MyUser(sptr) ? "remote " : ""), cli_name(sptr), cli_user(sptr)->username, cli_user(sptr)->realhost); return 0; } } if (!verify_sslclifp(sptr, aconf)) { send_reply(sptr, ERR_SSLCLIFP); sendto_opmask_butone_global(&me, SNO_OLDREALOP, "Failed %sOPER attempt by %s " "(%s@%s) (SSL fingerprint mismatch)", (!MyUser(sptr) ? "remote " : ""), cli_name(sptr), cli_user(sptr)->username, cli_user(sptr)->realhost); return 0; } if (oper_password_match(password, aconf->passwd)) { if (MyUser(sptr)) { int attach_result = attach_conf(sptr, aconf); if ((ACR_OK != attach_result) && (ACR_ALREADY_AUTHORIZED != attach_result)) { send_reply(sptr, ERR_NOOPERHOST); sendto_opmask_butone_global(&me, SNO_OLDREALOP, "Failed %sOPER attempt by %s " "(%s@%s) (no operator block)", (!MyUser(sptr) ? "remote " : ""), cli_name(sptr), cli_user(sptr)->username, cli_user(sptr)->realhost); return 0; } } *_aconf = aconf; return -1; } else { send_reply(sptr, ERR_PASSWDMISMATCH); sendto_opmask_butone_global(&me, SNO_OLDREALOP, "Failed %sOPER attempt by %s (%s@%s) " "(password mis-match)", (!MyUser(sptr) ? "remote " : ""), cli_name(sptr), cli_user(sptr)->username, cli_user(sptr)->realhost); return 0; } }
int ModbusSlave232::update(int *regs, unsigned int regs_size) { unsigned char query[MAX_MESSAGE_LENGTH]; unsigned char errpacket[EXCEPTION_SIZE + CHECKSUM_SIZE]; unsigned int start_addr; int exception; int length = Serial.available(); unsigned long now = millis(); if (length == 0) { lastBytesReceived = 0; return 0; } if (lastBytesReceived != length) { lastBytesReceived = length; Nowdt = now + T35; return 0; } if (now < Nowdt) return 0; lastBytesReceived = 0; length = modbus_request(query); if (length < 1) return length; exception = validate_request(query, length, regs_size); if (exception) { build_error_packet( query[FUNC], exception, errpacket); send_reply(errpacket, EXCEPTION_SIZE); return (exception); } start_addr = ((int) query[START_H] << 8) + (int) query[START_L]; switch (query[FUNC]) { case FC_READ_REGS: return read_holding_registers( start_addr, query[REGS_L], regs); break; case FC_WRITE_REGS: return preset_multiple_registers( start_addr, query[REGS_L], query, regs); break; case FC_WRITE_REG: write_single_register( start_addr, query, regs); break; } }
static void process_message(struct owner *o, struct message *msg, int cfd, int fd) { struct fd_store *f = NULL; struct fd_store *newf = NULL; struct fd_store **fp; struct req_data *d; pthread_t tid; int res; #ifdef DEBUG fprintf(stderr, "ulockmgr_server: %i %i %i %lli %lli\n", msg->cmd, msg->lock.l_type, msg->lock.l_whence, msg->lock.l_start, msg->lock.l_len); #endif if (msg->cmd == F_SETLK && msg->lock.l_type == F_UNLCK && msg->lock.l_start == 0 && msg->lock.l_len == 0) { for (fp = &o->fds; *fp;) { f = *fp; if (f->origfd == msg->fd && !f->inuse) { close(f->fd); *fp = f->next; free(f); } else fp = &f->next; } if (!msg->nofd) close(fd); msg->error = 0; send_reply(cfd, msg); close(cfd); return; } if (msg->nofd) { for (fp = &o->fds; *fp; fp = &(*fp)->next) { f = *fp; if (f->origfd == msg->fd) break; } if (!*fp) { fprintf(stderr, "ulockmgr_server: fd %i not found\n", msg->fd); msg->error = EIO; send_reply(cfd, msg); close(cfd); return; } } else { newf = f = malloc(sizeof(struct fd_store)); if (!f) { msg->error = ENOLCK; send_reply(cfd, msg); close(cfd); return; } f->fd = fd; f->origfd = msg->fd; f->inuse = 0; } if (msg->cmd == F_GETLK || msg->cmd == F_SETLK || msg->lock.l_type == F_UNLCK) { res = fcntl(f->fd, msg->cmd, &msg->lock); msg->error = (res == -1) ? errno : 0; send_reply(cfd, msg); close(cfd); if (newf) { newf->next = o->fds; o->fds = newf; } return; } d = malloc(sizeof(struct req_data)); if (!d) { msg->error = ENOLCK; send_reply(cfd, msg); close(cfd); free(newf); return; } f->inuse++; d->o = o; d->cfd = cfd; d->f = f; d->msg = *msg; res = pthread_create(&tid, NULL, process_request, d); if (res) { msg->error = ENOLCK; send_reply(cfd, msg); close(cfd); free(d); f->inuse--; free(newf); return; } if (newf) { newf->next = o->fds; o->fds = newf; } pthread_detach(tid); }
void cli_reserve_lock(int sock, oid_t *pid) { if (try_reserve(*pid)) send_reply(sock, NULL, 0); else send_error(sock, EBUSY); }
static void process_request(cdata_comm_t *com, int sockfd, vol_file_handle_t *v_handle) { ui08 *data_ptr = NULL; /* pointer to data */ cdata_info_t info; cdata_reply_t reply; Glob->time_last_request = time((time_t *) NULL); Glob->n_data_requests++; if(Glob->params.debug) { fprintf(stderr, "Received request\n"); } PMU_auto_register("Processing request"); /* * if plane_heights are requested, request info as well */ if (com->primary_com & GET_PLANE_HEIGHTS) { com->primary_com |= GET_INFO; } /* * Set default values in reply */ initialize_reply(&reply, com); /* * In the case of a request for new data when no realtime file * is available, change the request to GET_MOST_RECENT */ if (com->primary_com & GET_NEW && !Glob->params.use_realtime_file) { com->primary_com &= ~GET_NEW; com->primary_com |= GET_MOST_RECENT; } /* * read in the data volume */ PMU_auto_register("Reading in data volume"); if (read_volume(v_handle, com)) { /* * read failed */ reply.status |= NO_INFO | NO_DATA; } else if (com->data_field >= v_handle->vol_params->nfields) { /* * field number is out of range */ if (Glob->params.debug) { fprintf(stderr, "Field num %ld exceeds max of %ld\n", (long) com->data_field, (long) v_handle->vol_params->nfields); } reply.status |= NO_INFO | NO_DATA; } else { if (com->primary_com & GET_NEW) { reply.status |= NEW_DATA; } copy_vol_params_to_info(v_handle, &info); copy_grid_params_to_info(v_handle, com, &info); copy_field_params_to_info(v_handle, &info, com->data_field); /* * get the data if requested */ if(com->primary_com & GET_DATA) { data_ptr = (ui08 *) NULL; if(Glob->params.debug) { fprintf(stderr, "getting data\n"); } data_ptr = get_grid_data(com, &reply, &info, v_handle); } } /* if (read_volume(v_handle, com)) */ PMU_auto_register("Sending reply"); send_reply(com, &reply, &info, data_ptr, sockfd, v_handle); if(data_ptr != NULL) { ufree((char *) data_ptr); if (Glob->params.free_volume) RfFreeVolPlanes(v_handle, "process_request"); } }
void cli_lock(int sock, oid_t *pid) { create_lock(*pid); send_reply(sock, NULL, 0); }
int fuse_reply_err(fuse_req_t req, int err) { return send_reply(req, -err, NULL, 0); }
void cli_unlock(int sock, oid_t *pid) { remove_lock(*pid); send_reply(sock, NULL, 0); }
/** Attempt to send a sequence of bytes to the connection. * As a side effect, updates \a cptr's FLAG_BLOCKED setting * and sendB/sendK fields. * @param cptr Client that should receive data. * @param buf Message buffer to send to client. * @return Negative on connection-fatal error; otherwise * number of bytes sent. */ unsigned int deliver_it(struct Client *cptr, struct MsgQ *buf) { unsigned int bytes_written = 0; unsigned int bytes_count = 0; assert(0 != cptr); #if defined(USE_SSL) switch (client_sendv(cptr, buf, &bytes_count, &bytes_written)) { #else switch (os_sendv_nonb(cli_fd(cptr), buf, &bytes_count, &bytes_written)) { #endif case IO_SUCCESS: ClrFlag(cptr, FLAG_BLOCKED); cli_sendB(cptr) += bytes_written; cli_sendB(&me) += bytes_written; /* A partial write implies that future writes will block. */ if (bytes_written < bytes_count) SetFlag(cptr, FLAG_BLOCKED); break; case IO_BLOCKED: SetFlag(cptr, FLAG_BLOCKED); break; case IO_FAILURE: cli_error(cptr) = errno; SetFlag(cptr, FLAG_DEADSOCKET); break; } return bytes_written; } /** Complete non-blocking connect()-sequence. Check access and * terminate connection, if trouble detected. * @param cptr Client to which we have connected, with all ConfItem structs attached. * @return Zero on failure (caller should exit_client()), non-zero on success. */ static int completed_connection(struct Client* cptr) { struct ConfItem *aconf; time_t newts; struct Client *acptr; int i; #if defined(USE_SSL) char *sslfp; int r; #endif assert(0 != cptr); /* * get the socket status from the fd first to check if * connection actually succeeded */ if ((cli_error(cptr) = os_get_sockerr(cli_fd(cptr)))) { const char* msg = strerror(cli_error(cptr)); if (!msg) msg = "Unknown error"; sendto_opmask(0, SNO_OLDSNO, "Connection failed to %s: %s", cli_name(cptr), msg); return 0; } if (!(aconf = find_conf_byname(cli_confs(cptr), cli_name(cptr), CONF_SERVER))) { sendto_opmask(0, SNO_OLDSNO, "Lost Server Line for %s", cli_name(cptr)); return 0; } #if defined(USE_SSL) if (aconf->flags & CONF_SSL) { r = ssl_connect(&(cli_socket(cptr))); if (r == -1) { sendto_opmask(0, SNO_OLDSNO, "Connection failed to %s: SSL error", cli_name(cptr)); return 0; } else if (r == 0) return 1; sslfp = ssl_get_fingerprint(cli_socket(cptr).s_ssl); if (sslfp) ircd_strncpy(cli_sslclifp(cptr), sslfp, BUFSIZE+1); SetSSL(cptr); } #endif if (s_state(&(cli_socket(cptr))) == SS_CONNECTING) socket_state(&(cli_socket(cptr)), SS_CONNECTED); if (!EmptyString(aconf->passwd)) sendrawto_one(cptr, MSG_PASS " :%s", aconf->passwd); /* * Create a unique timestamp */ newts = TStime(); for (i = HighestFd; i > -1; --i) { if ((acptr = LocalClientArray[i]) && (IsServer(acptr) || IsHandshake(acptr))) { if (cli_serv(acptr)->timestamp >= newts) newts = cli_serv(acptr)->timestamp + 1; } } assert(0 != cli_serv(cptr)); cli_serv(cptr)->timestamp = newts; SetHandshake(cptr); /* * Make us timeout after twice the timeout for DNS look ups */ cli_lasttime(cptr) = CurrentTime; ClearPingSent(cptr); /* TODO: NEGOCIACION envia_config_req(cptr); */ sendrawto_one(cptr, MSG_SERVER " %s 1 %Tu %Tu J%s %s%s +%s6 :%s", cli_name(&me), cli_serv(&me)->timestamp, newts, MAJOR_PROTOCOL, NumServCap(&me), feature_bool(FEAT_HUB) ? "h" : "", cli_info(&me)); #if defined(DDB) ddb_burst(cptr); #endif return (IsDead(cptr)) ? 0 : 1; } /** Close the physical connection. Side effects: MyConnect(cptr) * becomes false and cptr->from becomes NULL. * @param cptr Client to disconnect. */ void close_connection(struct Client *cptr) { struct ConfItem* aconf; if (IsServer(cptr)) { ServerStats->is_sv++; ServerStats->is_sbs += cli_sendB(cptr); ServerStats->is_sbr += cli_receiveB(cptr); ServerStats->is_sti += CurrentTime - cli_firsttime(cptr); /* * If the connection has been up for a long amount of time, schedule * a 'quick' reconnect, else reset the next-connect cycle. */ if ((aconf = find_conf_exact(cli_name(cptr), cptr, CONF_SERVER))) { /* * Reschedule a faster reconnect, if this was a automatically * connected configuration entry. (Note that if we have had * a rehash in between, the status has been changed to * CONF_ILLEGAL). But only do this if it was a "good" link. */ aconf->hold = CurrentTime; aconf->hold += ((aconf->hold - cli_since(cptr) > feature_int(FEAT_HANGONGOODLINK)) ? feature_int(FEAT_HANGONRETRYDELAY) : ConfConFreq(aconf)); /* if (nextconnect > aconf->hold) */ /* nextconnect = aconf->hold; */ } } else if (IsUser(cptr)) { ServerStats->is_cl++; ServerStats->is_cbs += cli_sendB(cptr); ServerStats->is_cbr += cli_receiveB(cptr); ServerStats->is_cti += CurrentTime - cli_firsttime(cptr); } else ServerStats->is_ni++; #if defined(USE_ZLIB) /* * Siempre es una conexion nuestra */ if (cli_connect(cptr)->zlib_negociation & ZLIB_IN) { inflateEnd(cli_connect(cptr)->comp_in); MyFree(cli_connect(cptr)->comp_in); } if (cli_connect(cptr)->zlib_negociation & ZLIB_OUT) { deflateEnd(cli_connect(cptr)->comp_out); MyFree(cli_connect(cptr)->comp_out); } #endif if (-1 < cli_fd(cptr)) { flush_connections(cptr); LocalClientArray[cli_fd(cptr)] = 0; close(cli_fd(cptr)); socket_del(&(cli_socket(cptr))); /* queue a socket delete */ cli_fd(cptr) = -1; cli_freeflag(cptr) &= ~FREEFLAG_SOCKET; } SetFlag(cptr, FLAG_DEADSOCKET); MsgQClear(&(cli_sendQ(cptr))); client_drop_sendq(cli_connect(cptr)); DBufClear(&(cli_recvQ(cptr))); memset(cli_passwd(cptr), 0, sizeof(cli_passwd(cptr))); set_snomask(cptr, 0, SNO_SET); det_confs_butmask(cptr, 0); if (cli_listener(cptr)) { release_listener(cli_listener(cptr)); cli_listener(cptr) = 0; } for ( ; HighestFd > 0; --HighestFd) { if (LocalClientArray[HighestFd]) break; } } /** Close all unregistered connections. * @param source Oper who requested the close. * @return Number of closed connections. */ int net_close_unregistered_connections(struct Client* source) { int i; struct Client* cptr; int count = 0; assert(0 != source); for (i = HighestFd; i > 0; --i) { if ((cptr = LocalClientArray[i]) && !IsRegistered(cptr)) { send_reply(source, RPL_CLOSING, get_client_name(source, HIDE_IP)); exit_client(source, cptr, &me, "Oper Closing"); ++count; } } return count; }
/** Report server statistics to a client. * @param cptr Client who wants statistics. * @param sd StatDesc structure being looked up (unused). * @param param Extra parameter passed by user (unused). */ void tstats(struct Client *cptr, const struct StatDesc *sd, char *param) { struct Client *acptr; int i; struct ServerStatistics *sp; struct ServerStatistics tmp; sp = &tmp; memcpy(sp, ServerStats, sizeof(struct ServerStatistics)); for (i = 0; i < MAXCONNECTIONS; i++) { if (!(acptr = LocalClientArray[i])) continue; if (IsServer(acptr)) { sp->is_sbs += cli_sendB(acptr); sp->is_sbr += cli_receiveB(acptr); sp->is_sti += CurrentTime - cli_firsttime(acptr); sp->is_sv++; } else if (IsUser(acptr)) { sp->is_cbs += cli_sendB(acptr); sp->is_cbr += cli_receiveB(acptr); sp->is_cti += CurrentTime - cli_firsttime(acptr); sp->is_cl++; } else if (IsUnknown(acptr)) sp->is_ni++; } send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":accepts %u refused %u", sp->is_ac, sp->is_ref); send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":unknown commands %u prefixes %u", sp->is_unco, sp->is_unpf); send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":nick collisions %u unknown closes %u", sp->is_kill, sp->is_ni); send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":wrong direction %u empty %u", sp->is_wrdi, sp->is_empt); send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":numerics seen %u mode fakes %u", sp->is_num, sp->is_fake); send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":auth successes %u fails %u", sp->is_asuc, sp->is_abad); send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":local connections %u", sp->is_loc); send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":Client server"); send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":connected %u %u", sp->is_cl, sp->is_sv); send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":bytes sent %Lu %Lu", sp->is_cbs, sp->is_sbs); send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":bytes recv %Lu %Lu", sp->is_cbr, sp->is_sbr); send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":time connected %Lu %Lu", sp->is_cti, sp->is_sti); }
/* * This function is responsible for enabling, disabling, resetting and * gathering data related to microstate accounting. * * Managed threads and unmanaged threads are handled differently. * - managed threads get a misc_aux job telling them to switch on msacc * - unmanaged have some fields protected by a mutex that has to be taken * before any values can be updated * * For performance reasons there is also a global value erts_msacc_enabled * that controls the state of all threads. Statistics gathering is only on * if erts_msacc_enabled && msacc is true. */ Eterm erts_msacc_request(Process *c_p, int action, Eterm *threads) { #ifdef ERTS_ENABLE_MSACC ErtsMsAcc *msacc = ERTS_MSACC_TSD_GET(); ErtsSchedulerData *esdp = erts_proc_sched_data(c_p); Eterm ref; ErtsMSAccReq *msaccrp; Eterm *hp; #ifdef ERTS_MSACC_ALWAYS_ON if (action == ERTS_MSACC_ENABLE || action == ERTS_MSACC_DISABLE) return THE_NON_VALUE; #else /* take care of double enable, and double disable here */ if (msacc && action == ERTS_MSACC_ENABLE) { return THE_NON_VALUE; } else if (!msacc && action == ERTS_MSACC_DISABLE) { return THE_NON_VALUE; } #endif ref = erts_make_ref(c_p); msaccrp = erts_alloc(ERTS_ALC_T_MSACC, sizeof(ErtsMSAccReq)); hp = &msaccrp->ref_heap[0]; msaccrp->action = action; msaccrp->proc = c_p; msaccrp->ref = STORE_NC(&hp, NULL, ref); msaccrp->req_sched = esdp->no; #ifdef ERTS_SMP *threads = erts_no_schedulers; *threads += 1; /* aux thread */ #else *threads = 1; #endif erts_smp_atomic32_init_nob(&msaccrp->refc,(erts_aint32_t)*threads); erts_proc_add_refc(c_p, *threads); if (erts_no_schedulers > 1) erts_schedule_multi_misc_aux_work(1, erts_no_schedulers, reply_msacc, (void *) msaccrp); #ifdef ERTS_SMP /* aux thread */ erts_schedule_misc_aux_work(0, reply_msacc, (void *) msaccrp); #endif #ifdef USE_THREADS /* Manage unmanaged threads */ switch (action) { case ERTS_MSACC_GATHER: { Uint unmanaged_count; ErtsMsAcc *msacc, **unmanaged; int i = 0; /* we copy a list of pointers here so that we do not have to have the msacc_mutex when sending messages */ erts_rwmtx_rlock(&msacc_mutex); unmanaged_count = msacc_unmanaged_count; unmanaged = erts_alloc(ERTS_ALC_T_MSACC, sizeof(ErtsMsAcc*)*unmanaged_count); for (i = 0, msacc = msacc_unmanaged; i < unmanaged_count; i++, msacc = msacc->next) { unmanaged[i] = msacc; } erts_rwmtx_runlock(&msacc_mutex); for (i = 0; i < unmanaged_count; i++) { erts_mtx_lock(&unmanaged[i]->mtx); if (unmanaged[i]->perf_counter) { ErtsSysPerfCounter perf_counter; /* if enabled update stats */ perf_counter = erts_sys_perf_counter(); unmanaged[i]->perf_counters[unmanaged[i]->state] += perf_counter - unmanaged[i]->perf_counter; unmanaged[i]->perf_counter = perf_counter; } erts_mtx_unlock(&unmanaged[i]->mtx); send_reply(unmanaged[i],msaccrp); } erts_free(ERTS_ALC_T_MSACC,unmanaged); /* We have just sent unmanaged_count messages, so bump no of threads */ *threads += unmanaged_count; break; } case ERTS_MSACC_RESET: { ErtsMsAcc *msacc; erts_rwmtx_rlock(&msacc_mutex); for (msacc = msacc_unmanaged; msacc != NULL; msacc = msacc->next) erts_msacc_reset(msacc); erts_rwmtx_runlock(&msacc_mutex); break; } case ERTS_MSACC_ENABLE: { erts_rwmtx_rlock(&msacc_mutex); for (msacc = msacc_unmanaged; msacc != NULL; msacc = msacc->next) { erts_mtx_lock(&msacc->mtx); msacc->perf_counter = erts_sys_perf_counter(); /* we assume the unmanaged thread is sleeping */ msacc->state = ERTS_MSACC_STATE_SLEEP; erts_mtx_unlock(&msacc->mtx); } erts_rwmtx_runlock(&msacc_mutex); break; } case ERTS_MSACC_DISABLE: { ErtsSysPerfCounter perf_counter; erts_rwmtx_rlock(&msacc_mutex); /* make sure to update stats with latest results */ for (msacc = msacc_unmanaged; msacc != NULL; msacc = msacc->next) { erts_mtx_lock(&msacc->mtx); perf_counter = erts_sys_perf_counter(); msacc->perf_counters[msacc->state] += perf_counter - msacc->perf_counter; msacc->perf_counter = 0; erts_mtx_unlock(&msacc->mtx); } erts_rwmtx_runlock(&msacc_mutex); break; } default: { ASSERT(0); } } #endif *threads = make_small(*threads); reply_msacc((void *) msaccrp); #ifndef ERTS_MSACC_ALWAYS_ON /* enable/disable the global value */ if (action == ERTS_MSACC_ENABLE) { erts_msacc_enabled = 1; } else if (action == ERTS_MSACC_DISABLE) { erts_msacc_enabled = 0; } #endif return ref; #else return THE_NON_VALUE; #endif }
/* * mo_jupe - oper message handler * * parv[0] = Send prefix * parv[1] = [[+|-]<server name>] * * Local (to me) style: * * parv[2] = [Expiration offset] * parv[3] = [Comment] * * Global (or remote local) style: * * parv[2] = [target] * parv[3] = [Expiration offset] * parv[4] = [Comment] * */ int mo_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; char *server = parv[1], *target = 0, *reason; if (parc < 2) return jupe_list(sptr, 0); if (*server == '+') { flags |= JUPE_ACTIVE; server++; } else if (*server == '-') server++; else return jupe_list(sptr, server); if (!feature_bool(FEAT_CONFIG_OPERCMDS)) return send_reply(sptr, ERR_DISABLED, "JUPE"); if (parc == 4) { if (is_timestamp(parv[2])) { expire_off = atoi(parv[2]); } else { expire_off = ParseInterval(parv[2]); } reason = parv[3]; flags |= JUPE_LOCAL; } else if (parc > 4) { target = parv[2]; if (is_timestamp(parv[3])) { expire_off = atoi(parv[3]); } else { expire_off = ParseInterval(parv[3]); } reason = parv[4]; } else return need_more_params(sptr, "JUPE"); if (target) { if (!(target[0] == '*' && target[1] == '\0')) { if (!(acptr = find_match_server(target))) return send_reply(sptr, ERR_NOSUCHSERVER, target); if (!IsMe(acptr)) { /* manually propagate, since we don't set it */ if (!HasPriv(sptr, PRIV_JUPE)) return send_reply(sptr, ERR_NOPRIVILEGES); sendcmdto_one(sptr, CMD_JUPE, acptr, "%C %c%s %s %Tu :%s", acptr, flags & JUPE_ACTIVE ? '+' : '-', server, parv[3], TStime(), reason); return 0; } else if (!HasPriv(sptr, PRIV_LOCAL_JUPE)) return send_reply(sptr, ERR_NOPRIVILEGES); flags |= JUPE_LOCAL; } else if (!HasPriv(sptr, PRIV_JUPE)) return send_reply(sptr, ERR_NOPRIVILEGES); } ajupe = jupe_find(server); if (ajupe) { if (JupeIsLocal(ajupe) && !(flags & JUPE_LOCAL)) /* global over local */ jupe_free(ajupe); else { if (flags & JUPE_ACTIVE) return jupe_activate(cptr, sptr, ajupe, TStime(), flags); else return jupe_deactivate(cptr, sptr, ajupe, TStime(), flags); } } return jupe_add(cptr, sptr, server, reason, expire_off, TStime(), flags); }