DLLFUNC int m_rawto(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
aClient *acptr = NULL;
if (!IsULine(sptr))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return -1;
}
if (parc < 3)
{
sendto_one(sptr, err_str(ERR_NEEDMOREPARAMS),
me.name, parv[0], "RAWTO");
return -1;
}
if ((acptr = find_client(parv[1], NULL)))
{
if (MyConnect(acptr))
{
sendto_one(acptr, "%s", parv[2]);
return 0;
}
else
{
sendto_one(acptr, ":%s %s %s :%s",
parv[0], IsToken(acptr->from) ? TOK_RAWTO : MSG_RAWTO,
parv[1], parv[2]);
return 0;
}
}
return 0;
}
/*
* m_samode
* parv[0] = sender
* parv[1] = channel
* parv[2] = modes
* -t
*/
DLLFUNC CMD_FUNC(m_samode)
{
aChannel *chptr;
if (!IsPrivileged(cptr) || !IsSAdmin(sptr))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if (parc > 2)
{
chptr = find_channel(parv[1], NullChn);
if (chptr == NullChn)
return 0;
}
else
{
sendto_one(sptr, err_str(ERR_NEEDMOREPARAMS),
me.name, parv[0], "SAMODE");
return 0;
}
opermode = 0;
(void)do_mode(chptr, cptr, sptr, parc - 2, parv + 2, 0, 1);
return 0;
}
Boolean memAccess(ArmMem* mem, UInt32 addr, UInt8 size, Boolean write, void* buf){
UInt8 i;
for(i = 0; i < MAX_MEM_REGIONS; i++){
if(mem->regions[i].pa <= addr && mem->regions[i].pa + mem->regions[i].sz > addr){
return mem->regions[i].aF(mem->regions[i].uD, addr, size, write & 0x7F, buf);
}
}
if(!(write & 0x80)){ //high bit in write tells us to not print this error (used by gdb stub)
err_str("Memory ");
err_str(write ? "write" : "read");
err_str(" of ");
err_dec(size);
err_str(" bytes at physical addr 0x");
err_hex(addr);
err_str(" fails, halting\r\n");
while(1);
}
return false;
}
DLLFUNC int m_lag(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
if (MyClient(sptr))
if (!IsAnOper(sptr))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name,
parv[0]);
return 0;
}
if (parc < 2)
{
sendto_one(sptr, err_str(ERR_NEEDMOREPARAMS),
me.name, parv[0], "LAG");
return 0;
}
if (*parv[1] == '\0')
{
sendto_one(sptr, err_str(ERR_NEEDMOREPARAMS),
me.name, parv[0], "LAG");
return 0;
}
if (hunt_server_token(cptr, sptr, MSG_LAG, TOK_LAG, ":%s", 1, parc,
parv) == HUNTED_NOSUCH)
{
return 0;
}
sendto_one(sptr, ":%s NOTICE %s :Lag reply -- %s %s %li",
me.name, sptr->name, me.name, parv[1], TStime());
return 0;
}
static bool delta_mjpeg_check_status(struct delta_ctx *pctx,
struct jpeg_decode_return_params_t *status)
{
struct delta_dev *delta = pctx->dev;
bool dump = false;
if (status->error_code == JPEG_DECODER_NO_ERROR)
goto out;
if (is_stream_error(status->error_code)) {
dev_warn_ratelimited(delta->dev,
"%s firmware: stream error @ frame %d (%s)\n",
pctx->name, pctx->decoded_frames,
err_str(status->error_code));
pctx->stream_errors++;
} else {
dev_warn_ratelimited(delta->dev,
"%s firmware: decode error @ frame %d (%s)\n",
pctx->name, pctx->decoded_frames,
err_str(status->error_code));
pctx->decode_errors++;
dump = true;
}
out:
dev_dbg(delta->dev,
"%s firmware: decoding time(us)=%d\n", pctx->name,
status->decode_time_in_us);
return dump;
}
/*
** m_whowas
** parv[0] = sender prefix
** parv[1] = nickname queried
*/
DLLFUNC CMD_FUNC(m_whowas)
{
aWhowas *temp;
int cur = 0;
int max = -1, found = 0;
char *p, *nick;
if (parc < 2)
{
sendto_one(sptr, err_str(ERR_NONICKNAMEGIVEN),
me.name, parv[0]);
return 0;
}
if (parc > 2)
max = atoi(parv[2]);
if (parc > 3)
if (hunt_server_token(cptr, sptr, MSG_WHOWAS, TOK_WHOWAS, "%s %s :%s", 3, parc,
parv))
return 0;
if (!MyConnect(sptr) && (max > 20))
max = 20;
p = (char *)strchr(parv[1], ',');
if (p)
*p = '\0';
nick = parv[1];
temp = WHOWASHASH[hash_whowas_name(nick)];
found = 0;
for (; temp; temp = temp->next)
{
if (!mycmp(nick, temp->name))
{
sendto_one(sptr, rpl_str(RPL_WHOWASUSER),
me.name, parv[0], temp->name,
temp->username,
(IsOper(sptr) ? temp->hostname :
(*temp->virthost !=
'\0') ? temp->virthost : temp->hostname),
temp->realname);
if (!((Find_uline(temp->servername)) && !IsOper(sptr) && HIDE_ULINES))
sendto_one(sptr, rpl_str(RPL_WHOISSERVER), me.name,
parv[0], temp->name, temp->servername,
myctime(temp->logoff));
cur++;
found++;
}
if (max > 0 && cur >= max)
break;
}
if (!found)
sendto_one(sptr, err_str(ERR_WASNOSUCHNICK),
me.name, parv[0], nick);
sendto_one(sptr, rpl_str(RPL_ENDOFWHOWAS), me.name, parv[0], parv[1]);
return 0;
}
/*
** m_pong
** parv[0] = sender prefix
** parv[1] = origin
** parv[2] = destination
*/
DLLFUNC int m_pong(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
aClient *acptr;
char *origin, *destination;
#ifdef NOSPOOF
if (!IsRegistered(cptr))
return m_nospoof(cptr, sptr, parc, parv);
#endif
if (parc < 2 || *parv[1] == '\0')
{
sendto_one(sptr, err_str(ERR_NOORIGIN), me.name, parv[0]);
return 0;
}
origin = parv[1];
destination = parv[2];
cptr->flags &= ~FLAGS_PINGSENT;
sptr->flags &= ~FLAGS_PINGSENT;
/* Remote pongs for clients? uhh... */
if (MyClient(sptr) || !IsRegistered(sptr))
destination = NULL;
if (!BadPtr(destination) && mycmp(destination, me.name) != 0)
{
if ((acptr = find_client(destination, NULL)) ||
(acptr = find_server_quick(destination)))
{
if (!IsServer(cptr) && !IsServer(acptr))
{
sendto_one(sptr, err_str(ERR_NOSUCHSERVER),
me.name, parv[0], destination);
return 0;
}
else
sendto_one(acptr, ":%s PONG %s %s",
parv[0], origin, destination);
}
else
{
sendto_one(sptr, err_str(ERR_NOSUCHSERVER),
me.name, parv[0], destination);
return 0;
}
}
#ifdef DEBUGMODE
else
Debug((DEBUG_NOTICE, "PONG: %s %s", origin,
destination ? destination : "*"));
#endif
return 0;
}
int add_listmode(Ban **list, aClient *cptr, aChannel *chptr, char *banid)
{
Ban *ban;
int cnt = 0, len;
if (MyClient(cptr))
(void)collapse(banid);
len = strlen(banid);
if (!*list && ((len > MAXBANLENGTH) || (MAXBANS < 1)))
{
sendto_one(cptr, err_str(ERR_BANLISTFULL),
me.name, cptr->name, chptr->chname, banid);
return -1;
}
for (ban = *list; ban; ban = ban->next)
{
len += strlen(ban->banstr);
if (MyClient(cptr))
if ((len > MAXBANLENGTH) || (++cnt >= MAXBANS))
{
sendto_one(cptr, err_str(ERR_BANLISTFULL),
me.name, cptr->name, chptr->chname, banid);
return -1;
}
else
{
#ifdef SOCALLEDSMARTBANNING
/* Temp workaround added in b19. -- Syzop */
if (!mycmp(ban->banstr, banid) || (!strchr(banid, '\\') && !strchr(ban->banstr, '\\')))
if (!match(ban->banstr, banid))
return -1;
#endif
if (!mycmp(ban->banstr, banid))
return -1;
}
else if (!mycmp(ban->banstr, banid))
return -1;
}
ban = make_ban();
bzero((char *)ban, sizeof(Ban));
ban->next = *list;
ban->banstr = (char *)MyMalloc(strlen(banid) + 1);
(void)strcpy(ban->banstr, banid);
ban->who = (char *)MyMalloc(strlen(cptr->name) + 1);
(void)strcpy(ban->who, cptr->name);
ban->when = TStime();
*list = ban;
return 0;
}
DLLFUNC CMD_FUNC(m_starttls)
{
if (!MyConnect(sptr) || !IsUnknown(sptr))
return 0;
#ifndef USE_SSL
/* sendnotice(sptr, "This server does not support SSL"); */
/* or numeric 691? */
/* actually... it's probably best to just act like we don't know this command...? */
sendto_one(sptr, err_str(ERR_NOTREGISTERED), me.name, "STARTTLS");
return 0;
#else
if (iConf.ssl_options & SSLFLAG_NOSTARTTLS)
{
sendto_one(sptr, err_str(ERR_NOTREGISTERED), me.name, "STARTTLS");
return 0;
}
if (IsSecure(sptr))
{
sendto_one(sptr, err_str(ERR_STARTTLS), me.name, !BadPtr(sptr->name) ? sptr->name : "*", "STARTTLS failed. Already using TLS.");
return 0;
}
dbuf_delete(&sptr->recvQ, 1000000); /* Clear up any remaining plaintext commands */
sendto_one(sptr, rpl_str(RPL_STARTTLS), me.name, !BadPtr(sptr->name) ? sptr->name : "*");
send_queued(sptr);
SetSSLStartTLSHandshake(sptr);
Debug((DEBUG_DEBUG, "Starting SSL handshake (due to STARTTLS) for %s", sptr->sockhost));
if ((sptr->ssl = SSL_new(ctx_server)) == NULL)
goto fail;
sptr->flags |= FLAGS_SSL;
SSL_set_fd(sptr->ssl, sptr->fd);
SSL_set_nonblocking(sptr->ssl);
if (!ircd_SSL_accept(sptr, sptr->fd)) {
Debug((DEBUG_DEBUG, "Failed SSL accept handshake in instance 1: %s", sptr->sockhost));
SSL_set_shutdown(sptr->ssl, SSL_RECEIVED_SHUTDOWN);
SSL_smart_shutdown(sptr->ssl);
SSL_free(sptr->ssl);
goto fail;
}
/* HANDSHAKE IN PROGRESS */
return 0;
fail:
/* Failure */
sendto_one(sptr, err_str(ERR_STARTTLS), me.name, !BadPtr(sptr->name) ? sptr->name : "*", "STARTTLS failed");
sptr->ssl = NULL;
sptr->flags &= ~FLAGS_SSL;
SetUnknown(sptr);
return 0;
#endif
}
static void out (avatar_s *avatar, int rc)
{
if (avatar) {
format(" OUT %s<%d> %s=%s",
avatar->av_name, current->pid, avatar->av_last_op,
err_str(rc));
} else {
format(" OUT <no avatar><%d> %s",
current->pid, err_str(rc));
}
if (rc) {
format("[%d]", rc);
}
}
int m_sdesc(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
if (!IsAdmin(sptr) && !IsCoAdmin(sptr))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, sptr->name);
return 0;
}
if (parc < 2)
{
sendto_one(sptr, err_str(ERR_NEEDMOREPARAMS), me.name, sptr->name, "SDESC");
return 0;
}
if (strlen(parv[1]) < 1)
if (MyConnect(sptr))
{
sendto_one(sptr,
":%s NOTICE %s :*** Nothing to change to (SDESC)",
me.name, sptr->name);
return 0;
}
if (strlen(parv[1]) > (REALLEN))
{
if (MyConnect(sptr))
{
sendto_one(sptr,
":%s NOTICE %s :*** /SDESC Error: \"Server info\" may maximum be %i characters of length",
me.name, sptr->name, REALLEN);
}
return 0;
}
ircsprintf(sptr->srvptr->info, "%s", parv[1]);
sendto_serv_butone_token(cptr, sptr->name, MSG_SDESC, TOK_SDESC, ":%s",
parv[1]);
if (MyConnect(sptr))
{
sendto_one(sptr,
":%s NOTICE %s :Your \"server description\" is now set to be %s - you have to set it manually to undo it",
me.name, parv[0], parv[1]);
return 0;
}
sendto_ops("Server description for %s is now '%s' changed by %s",
sptr->srvptr->name, sptr->srvptr->info, parv[0]);
return 0;
}
/* Remove a temporary dccdeny line
* parv[0] - sender
* parv[1] - file/mask
*/
DLLFUNC CMD_FUNC(m_undccdeny)
{
ConfigItem_deny_dcc *p;
if (!MyClient(sptr))
return 0;
if (!IsAnOper(sptr) || !OPCanDCCDeny(sptr))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if (parc < 2)
{
sendto_one(sptr, err_str(ERR_NEEDMOREPARAMS), me.name, parv[0],
"UNDCCDENY");
return 0;
}
if (BadPtr(parv[1]))
{
sendto_one(sptr, err_str(ERR_NEEDMOREPARAMS), me.name, parv[0],
"UNDCCDENY");
return 0;
}
/* If we find an exact match even if it is a wild card only remove the exact match -- codemastr */
if ((p = Find_deny_dcc(parv[1])) && p->flag.type2 == CONF_BAN_TYPE_TEMPORARY)
{
sendto_ops("%s removed a temp dccdeny for %s", parv[0],
parv[1]);
DCCdeny_del(p);
return 1;
}
/* Next search using the wild card -- codemastr */
/* Uncommented by Stskeeps:
else if (dcc_del_wild_match(parv[1]) == 1)
sendto_ops
("%s removed a temp dccdeny for all dccdenys matching %s",
parv[0], parv[1]);
*/
/* If still no match, give an error */
else
sendto_one(sptr,
"NOTICE %s :*** Unable to find a temp dccdeny matching %s",
parv[0], parv[1]);
return 0;
}
/*
** find_chasing
** Find the client structure for a nick name (user) using history
** mechanism if necessary. If the client is not found, an error
** message (NO SUCH NICK) is generated. If the client was found
** through the history, chasing will be 1 and otherwise 0.
*/
aClient *find_chasing(aClient *sptr, char *user, int *chasing)
{
aClient *who = find_client(user, (aClient *)NULL);
if (chasing)
*chasing = 0;
if (who)
{
if (!IsServer(who))
return who;
else
return NULL;
}
if (!(who = get_history(user, (long)KILLCHASETIMELIMIT)))
{
sendto_one(sptr, err_str(ERR_NOSUCHNICK),
me.name, sptr->name, user);
return NULL;
}
if (chasing)
*chasing = 1;
if (!IsServer(who))
return who;
else return NULL;
}
static u32 lua_co_create(LSTATE) {
lclosure_t *function = lstate_getfunction(0);
if (function->type != LUAF_LUA) {
err_str(0, "Lua function expected");
}
lthread_t *thread = gc_alloc(sizeof(lthread_t), LTHREAD);
thread->status = CO_NEVER_RUN;
thread->stack = mmap(NULL, CO_STACK_SIZE, PROT_WRITE | PROT_READ,
MAP_ANON | MAP_PRIVATE, -1, 0);
xassert(thread->stack != MAP_FAILED);
thread->caller = NULL;
thread->closure = function;
thread->frame = NULL;
thread->env = cur_thread->env;
thread->argvi = 0;
thread->argc = 0;
vm_stack_init(&thread->vm_stack, 20);
size_t *stack = (size_t*) ((size_t) thread->stack + CO_STACK_SIZE);
/* Bogus return address, and then actual address to return to */
size_t spaces = CALLEE_REGS + 2;
memset(stack - spaces, 0, sizeof(size_t) * spaces);
*(stack - 1) = 0;
*(stack - 2) = (size_t) coroutine_wrapper;
thread->curstack = stack - spaces;
lstate_return1(lv_thread(thread));
}
void ClientSocket::send(const std::vector<unsigned char>& buff) {
uint64_t written = 0;
std::string arr(buff.begin(), buff.end());
while (written < arr.length()) {
//Wait for the socket to become ready (we will block on sends for 1 second)
pollfd fds;
fds.fd = sock_fd;
fds.events = POLLOUT;
poll(&fds, 1, 1000);
if ( (fds.revents & POLLOUT) != POLLOUT) {
throw temporarily_unavailable();
}
//Send the previously unsent portions of the message.
int result = ::send(sock_fd, arr.c_str()+written, arr.length() - written, MSG_NOSIGNAL);
if (-1 == result) {
std::string err_str(strerror(errno));
if (err_str == "Broken pipe") {
err_str = "Connection closed by receiver (broken pipe)";
}
err_str = "Error sending data over socket: " + err_str;
//Clean up the socket (close connection and file descriptor)
socketCleanup(sock_fd);
throw std::runtime_error(err_str);
}
else {
written += result;
}
}
return;
}
/*
* SVSLOGIN message
*
* parv[0]: source
* parv[1]: propagation mask
* parv[2]: target PUID
* parv[3]: ESVID
*/
static int m_svslogin(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
if (!SASL_SERVER || MyClient(sptr) || (parc < 3) || !parv[3])
return 0;
if (!stricmp(parv[1], me.name))
{
aClient *target_p;
/* is the PUID valid? */
if ((target_p = decode_puid(parv[2])) == NULL)
return 0;
if (target_p->user == NULL)
make_user(target_p);
strlcpy(target_p->user->svid, parv[3], sizeof(target_p->user->svid));
sendto_one(target_p, err_str(RPL_LOGGEDIN), me.name,
BadPtr(target_p->name) ? "*" : target_p->name,
BadPtr(target_p->name) ? "*" : target_p->name,
BadPtr(target_p->user->username) ? "*" : target_p->user->username,
BadPtr(target_p->user->realhost) ? "*" : target_p->user->realhost,
target_p->user->svid, target_p->user->svid);
return 0;
}
/* not for us; propagate. */
sendto_serv_butone_token(cptr, parv[0], MSG_SVSLOGIN, TOK_SVSLOGIN, "%s %s %s",
parv[1], parv[2], parv[3]);
return 0;
}
int add_dccallow(aClient *sptr, aClient *optr)
{
Link *lp;
int cnt = 0;
for (lp = sptr->user->dccallow; lp; lp = lp->next)
{
if (lp->flags != DCC_LINK_ME)
continue;
if (++cnt >= MAXDCCALLOW)
{
sendto_one(sptr, err_str(ERR_TOOMANYDCC), me.name, sptr->name,
optr->name, MAXDCCALLOW);
return 0;
} else
if (lp->value.cptr == optr)
return 0;
}
lp = make_link();
lp->value.cptr = optr;
lp->flags = DCC_LINK_ME;
lp->next = sptr->user->dccallow;
sptr->user->dccallow = lp;
lp = make_link();
lp->value.cptr = sptr;
lp->flags = DCC_LINK_REMOTE;
lp->next = optr->user->dccallow;
optr->user->dccallow = lp;
sendto_one(sptr, rpl_str(RPL_DCCSTATUS), me.name, sptr->name, optr->name, "added to");
return 0;
}
void CamConfig::writeImagePixelFormat(uint32_t const width, uint32_t const height,
uint32_t const pixelformat) {
LOG_DEBUG("CamConfig: writeImagePixelFormat");
if(mFormat.type != V4L2_BUF_TYPE_VIDEO_CAPTURE) { // not yet requested?
readImageFormat();
}
if(width != 0)
mFormat.fmt.pix.width = width;
if(height != 0)
mFormat.fmt.pix.height = height;
if(pixelformat != 0)
mFormat.fmt.pix.pixelformat = pixelformat;
// Suggest the new format and fill mFormat with the actual one the driver choosed.
if(0 != ioctl(mFd, VIDIOC_S_FMT, &mFormat)) {
std::string err_str(strerror(errno));
if(errno == EINVAL) {
throw CamConfigException(err_str.insert(0,
"VIDIOC_S_FMT is not supported by device driver: "));
}
throw std::runtime_error(err_str.insert(0, "Could not write image format: "));
}
}
void CamConfig::writeStreamparm(uint32_t const numerator, uint32_t const denominator) {
LOG_DEBUG("CamConfig: writeStreamparm");
if(mStreamparm.type != V4L2_BUF_TYPE_VIDEO_CAPTURE) { // not yet requested?
LOG_DEBUG("Streamparm not yet requested, read streamparm.");
readStreamparm();
}
if(!hasCapabilityStreamparm(V4L2_CAP_TIMEPERFRAME)) {
throw CamConfigException("FPS-setting not supported by device driver.");
}
if(numerator != 0)
mStreamparm.parm.capture.timeperframe.numerator = numerator;
else
LOG_DEBUG("numerator is 0");
if(denominator != 0)
mStreamparm.parm.capture.timeperframe.denominator = denominator;
else
LOG_DEBUG("denominator is 0");
// Suggest the new stream parameters and fill mStreamparm with the actual one the driver choosed.
if(0 != ioctl(mFd, VIDIOC_S_PARM, &mStreamparm)) {
std::string err_str(strerror(errno));
if(errno == EINVAL) {
throw CamConfigException(err_str.insert(0,
"VIDIOC_S_PARM is not supported by device driver: "));
}
throw std::runtime_error(err_str.insert(0, "Could not write stream parameter: "));
}
}
/*
* exit_banned_client()
*
* Sends an appropriate ban message and disconnects a client.
*/
int
exit_banned_client(aClient *cptr, int loc, char type, char *banmsg, int fast)
{
char rbuf[512];
char *target = "*";
char *reason = "<no reason specified>";
if (cptr->name[0])
target = cptr->name;
if (!BadPtr(banmsg))
reason = banmsg;
ircsnprintf(rbuf, sizeof(rbuf), "%c-banned: %s", type, reason);
if (!fast)
{
sendto_one(&me, cptr, "NOTICE %s :*** You are banned from %s", target,
loc ? me.name : Network_Name);
sendto_one(&me, cptr, "NOTICE %s :*** Reason: %s", target, reason);
sendto_one(&me, cptr, "NOTICE %s :*** Connection info: %s [%s]", target,
get_client_name(cptr, FALSE),
cipntoa(cptr));
sendto_one(&me, cptr, "NOTICE %s :*** Ban contact: %s", target,
loc ? Local_Kline_Address : Network_Kline_Address);
sendto_one(&me, cptr, "NOTICE %s :*** When contacting %s, please include "
"all of the information shown above", target, Network_Name);
sendto_one(&me, cptr, err_str(ERR_YOUREBANNEDCREEP), me.name, target, rbuf);
throttle_force(cipntoa(cptr));
}
return exit_client(cptr, cptr, &me, rbuf);
}
int mode_is_ok(aClient *sptr, aChannel *chptr, char *para, int checkt, int what)
{
if ((checkt == EXCHK_ACCESS) || (checkt == EXCHK_ACCESS_ERR))
{
if (!is_chanowner(sptr, chptr))
{
if (checkt == EXCHK_ACCESS_ERR)
sendto_one(sptr, err_str(ERR_CHANOWNPRIVNEEDED), me.name, sptr->name, chptr->chname);
return 0;
} else {
return 1;
}
} else
if (checkt == EXCHK_PARAM)
{
if (!para)
{
sendto_one(sptr, ":%s NOTICE %s :chanmode +B requires a channel as parameter", me.name, sptr->name);
return 0;
}
if (strlen(para) > 32)
{
sendto_one(sptr, ":%s NOTICE %s :invalid parameter for chanmode +B", me.name, sptr->name);
return 0;
}
if (!IsChannelName(para))
{
sendto_one(sptr, ":%s NOTICE %s :invalid parameter for chanmode +B", me.name, sptr->name);
return 0;
}
return 1;
}
return 0;
}
/** User request to join a channel.
* This routine can be called from both m_join or via do_join->can_join->do_join
* if the channel is 'linked' (chmode +L). We use a counter 'bouncedtimes' which
* is set to 0 in m_join, increased every time we enter this loop and decreased
* anytime we leave the loop. So be carefull ;p.
*/
DLLFUNC CMD_FUNC(_do_join)
{
char jbuf[BUFSIZE];
Membership *lp;
aChannel *chptr;
char *name, *key = NULL, *link = NULL;
int i, flags = 0;
char *p = NULL, *p2 = NULL;
#define RET(x) { bouncedtimes--; return x; }
if (parc < 2 || *parv[1] == '\0')
{
sendto_one(sptr, err_str(ERR_NEEDMOREPARAMS),
me.name, parv[0], "JOIN");
return 0;
}
bouncedtimes++;
/* don't use 'return x;' but 'RET(x)' from here ;p */
if (bouncedtimes > MAXBOUNCE)
{
/* bounced too many times */
sendto_one(sptr,
":%s %s %s :*** Couldn't join %s ! - Link setting was too bouncy",
me.name, IsWebTV(sptr) ? "PRIVMSG" : "NOTICE", sptr->name, parv[1]);
RET(0)
}
/*
** m_admin
** parv[0] = sender prefix
** parv[1] = servername
*/
DLLFUNC CMD_FUNC(m_admin)
{
ConfigItem_admin *admin;
/* Users may want to get the address in case k-lined, etc. -- Barubary
* Only allow remote ADMINs if registered -- Barubary */
if (IsPerson(sptr) || IsServer(cptr))
if (hunt_server(cptr, sptr, ":%s ADMIN :%s", 1, parc, parv) != HUNTED_ISME)
return 0;
if (!conf_admin_tail)
{
sendto_one(sptr, err_str(ERR_NOADMININFO),
me.name, parv[0], me.name);
return 0;
}
sendto_one(sptr, rpl_str(RPL_ADMINME), me.name, parv[0], me.name);
/* cycle through the list backwards */
for (admin = conf_admin_tail; admin;
admin = (ConfigItem_admin *) admin->prev)
{
if (!admin->next)
sendto_one(sptr, rpl_str(RPL_ADMINLOC1),
me.name, parv[0], admin->line);
else if (!admin->next->next)
sendto_one(sptr, rpl_str(RPL_ADMINLOC2),
me.name, parv[0], admin->line);
else
sendto_one(sptr, rpl_str(RPL_ADMINEMAIL),
me.name, parv[0], admin->line);
}
return 0;
}
int modey_is_ok(aClient *sptr, aChannel *chptr, char *para, int checkt, int what)
{
short t;
if ((checkt == EXCHK_ACCESS) || (checkt == EXCHK_ACCESS_ERR))
{
if (!is_chan_op(sptr, chptr))
{
if (checkt == EXCHK_ACCESS_ERR)
sendto_one(sptr, err_str(ERR_CHANOPRIVSNEEDED), me.name, sptr->name, chptr->chname);
return 0;
} else {
return 1;
}
} else
if (checkt == EXCHK_PARAM)
{
t = (short)atoi(para);
if ((t < 0) || (t > 100))
{
sendto_one(sptr, ":%s NOTICE %s :chanmode +y requires a parameter in the range 0..100",
me.name, sptr->name);
return 0;
}
return 1;
}
return 0;
}
// Parts all insecure users on a +z channel (NOT KICK)
void f_part_insecure_users (aChannel *chptr)
{
Member *member, *mb2;
aClient *cptr;
char *comment = "Insecure user not allowed on secure channel (+z)";
for (member = chptr->members; member; member = mb2)
{
mb2 = member->next;
cptr = member->cptr;
if (MyClient(cptr) && !IsSecureConnect(cptr) && !IsULine(cptr))
{
RunHook4(HOOKTYPE_LOCAL_PART, cptr, &me, chptr, comment);
if ((chptr->mode.mode & MODE_AUDITORIUM) && is_chanownprotop(cptr, chptr))
{
sendto_chanops_butone(cptr, chptr, ":%s!%s@%s PART %s :%s",
cptr->name, cptr->user->username, GetHost(cptr), chptr->chname, comment);
sendto_prefix_one(cptr, &me, ":%s!%s@%s PART %s :%s",
cptr->name, cptr->user->username, GetHost(cptr), chptr->chname, comment);
}
else
{
sendto_channel_butserv(chptr, &me, ":%s!%s@%s PART %s :%s",
cptr->name, cptr->user->username, GetHost(cptr), chptr->chname, comment);
}
sendto_one(cptr, err_str(ERR_SECUREONLYCHAN), me.name, cptr->name, chptr->chname);
sendto_serv_butone_token(&me, cptr->name, MSG_PART, TOK_PART, "%s :%s", chptr->chname, comment);
remove_user_from_channel(cptr, chptr);
}
}
}
static Boolean pxa255pwrClkPrvPowerMgrMemAccessF(void* userData, UInt32 pa, UInt8 size, Boolean write, void* buf){
Pxa255pwrClk* pc = userData;
UInt32 val = 0;
if(size != 4) {
err_str(__FILE__ ": Unexpected ");
// err_str(write ? "write" : "read");
// err_str(" of ");
// err_dec(size);
// err_str(" bytes to 0x");
// err_hex(pa);
// err_str("\r\n");
return true; //we do not support non-word accesses
}
pa = (pa - PXA255_POWER_MANAGER_BASE) >> 2;
if(write) val = *(UInt32*)buf;
if(pa < 13){
if(write) pc->pwrRegs[pa] = val;
else val = pc->pwrRegs[pa];
}
if(!write) *(UInt32*)buf = val;
return true;
}
static int ovr_ircop_only(Cmdoverride *ovr, aClient *cptr, aClient *sptr, int parc, char *parv[]) {
if (IsPerson(sptr) && !IsOper(sptr)) {
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, sptr->name);
return -1;
}
return CallCmdoverride(ovr, cptr, sptr, parc, parv);
}
static std::string GetErrorReason() {
wchar_t* err;
FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
nullptr, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), reinterpret_cast<WCHAR*>(&err), 0, nullptr);
std::wstring err_str(err);
LocalFree(err);
return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>>().to_bytes(err_str);
}
/*
* SASL message
*
* parv[0]: prefix
* parv[1]: distribution mask
* parv[2]: target PUID
* parv[3]: mode/state
* parv[4]: data
* parv[5]: out-of-bound data
*/
static int m_sasl(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
if (!SASL_SERVER || MyClient(sptr) || (parc < 4) || !parv[4])
return 0;
if (!stricmp(parv[1], me.name))
{
aClient *target_p;
/* is the PUID valid? */
if ((target_p = decode_puid(parv[2])) == NULL)
return 0;
if (target_p->user == NULL)
make_user(target_p);
/* reject if another SASL agent is answering */
if (*target_p->sasl_agent && stricmp(parv[0], target_p->sasl_agent))
return 0;
else
strlcpy(target_p->sasl_agent, parv[0], sizeof(target_p->sasl_agent));
if (*parv[3] == 'C')
sendto_one(target_p, "AUTHENTICATE %s", parv[4]);
else if (*parv[3] == 'D')
{
if (*parv[4] == 'F')
sendto_one(target_p, err_str(ERR_SASLFAIL), me.name, BadPtr(target_p->name) ? "*" : target_p->name);
else if (*parv[4] == 'S')
{
target_p->sasl_complete++;
sendto_one(target_p, err_str(RPL_SASLSUCCESS), me.name, BadPtr(target_p->name) ? "*" : target_p->name);
}
*target_p->sasl_agent = '\0';
}
return 0;
}
/* not for us; propagate. */
sendto_serv_butone_token(cptr, parv[0], MSG_SASL, TOK_SASL, "%s %s %c %s %s",
parv[1], parv[2], *parv[3], parv[4], parc > 5 ? parv[5] : "");
return 0;
}
/*
* * check_registered user cancels message, if 'x' is not * registered
* (e.g. we don't know yet whether a server * or user)
*/
int
check_registered(aClient *sptr)
{
if (!IsRegistered(sptr)) {
sendto_one(sptr, err_str(ERR_NOTREGISTERED), me.name, "*");
return -1;
}
return 0;
}