void os_init(void)
{
MYSQL_ROW row;
unsigned int fields, rows;
Command *cmd;
MYSQL_RES *result;
maxusercnt = 0;
maxusertime = 0;
cmd = lookup_cmd(cmds, "GLOBAL");
if (cmd)
cmd->help_param1 = s_GlobalNoticer;
cmd = lookup_cmd(cmds, "ADMIN");
if (cmd)
cmd->help_param1 = s_NickServ;
cmd = lookup_cmd(cmds, "OPER");
if (cmd)
cmd->help_param1 = s_NickServ;
/* get the max user details */
result = smysql_bulk_query(mysqlconn, &fields, &rows,
"SELECT name, value FROM stat "
"WHERE name='maxusercnt' || name='maxusertime'");
while ((row = smysql_fetch_row(mysqlconn, result))) {
if (stricmp(row[0], "maxusercnt") == 0)
maxusercnt = atoi(row[1]);
else if (stricmp(row[0], "maxusertime") == 0)
maxusertime = atoi(row[1]);
}
mysql_free_result(result);
}
/*
* Register a new command
*/
int unixsock_register_cmd(char* command, unixsock_f* f)
{
str cmd;
struct unixsock_cmd* new_cmd;
cmd.s = command;
cmd.len = strlen(command);
if (lookup_cmd(&cmd)) {
LOG(L_ERR, "unixsock_register_cmd: Function already exists\n");
return -1;
}
new_cmd = pkg_malloc(sizeof(struct unixsock_cmd));
if (new_cmd == 0) {
LOG(L_ERR, "register_unixsock_cmd: Out of mem\n");
return -1;
}
new_cmd->name = cmd;
new_cmd->f = f;
new_cmd->next = cmd_list;
cmd_list = new_cmd;
DBG("unixsock_register_cmd: New command (%.*s) registered\n",
cmd.len, ZSW(cmd.s));
return 1;
}
void run_cmd(const char *service, User *u, Command *list, const char *cmd)
{
Command *c = lookup_cmd(list, cmd);
if (c && c->routine) {
if ((c->has_priv == NULL) || c->has_priv(u))
c->routine(u);
else
notice_lang(service, u, ACCESS_DENIED);
} else {
notice_lang(service, u, UNKNOWN_COMMAND_HELP, cmd, service);
}
}
void help_cmd(const char *service, User *u, Command *list, const char *cmd)
{
Command *c = lookup_cmd(list, cmd);
if (c) {
const char *p1 = c->help_param1,
*p2 = c->help_param2,
*p3 = c->help_param3,
*p4 = c->help_param4;
if (c->helpmsg_all >= 0) {
notice_help(service, u, c->helpmsg_all, p1, p2, p3, p4);
}
if (is_services_root(u)) {
if (c->helpmsg_root >= 0)
notice_help(service, u, c->helpmsg_root, p1, p2, p3, p4);
else if (c->helpmsg_all < 0)
notice_lang(service, u, NO_HELP_AVAILABLE, cmd);
} else if (is_services_admin(u)) {
if (c->helpmsg_admin >= 0)
notice_help(service, u, c->helpmsg_admin, p1, p2, p3, p4);
else if (c->helpmsg_all < 0)
notice_lang(service, u, NO_HELP_AVAILABLE, cmd);
} else if (is_services_oper(u)) {
if (c->helpmsg_oper >= 0)
notice_help(service, u, c->helpmsg_oper, p1, p2, p3, p4);
else if (c->helpmsg_all < 0)
notice_lang(service, u, NO_HELP_AVAILABLE, cmd);
} else {
if (c->helpmsg_reg >= 0)
notice_help(service, u, c->helpmsg_reg, p1, p2, p3, p4);
else if (c->helpmsg_all < 0)
notice_lang(service, u, NO_HELP_AVAILABLE, cmd);
}
} else {
notice_lang(service, u, NO_HELP_AVAILABLE, cmd);
}
}
void run_cmd(const char *service, User *u, Command *list, const char *cmd, ChannelInfo *ci)
{
Command *c = lookup_cmd(list, cmd);
int ulevel = 0;
ulevel = check_cservice(u);
if ( (ulevel == 0) && ci )
ulevel = get_access(u, ci);
if ( ulevel == 0 )
if ( (stricmp(u->nick, ServicesRoot) == 0) && nick_recognized(u) )
ulevel = ACCLEV_GOD;
if (c && c->routine)
{
if ( ((c->has_priv == NULL) || c->has_priv(u)) && (ulevel >= c->level) )
c->routine(u);
else
notice_lang(service, u, ACCESS_DENIED);
} else {
notice_lang(service, u, UNKNOWN_COMMAND_HELP, cmd, service);
}
}
/**
* Generates response message for client
* @param cmd Current command
* @param state Current connection state
*/
void response(Command *cmd, State *state)
{
switch(lookup_cmd(cmd->command)){
case USER: ftp_user(cmd,state); break;
case PASS: ftp_pass(cmd,state); break;
case PASV: ftp_pasv(cmd,state); break;
case LIST: ftp_list(cmd,state); break;
case CWD: ftp_cwd(cmd,state); break;
case PWD: ftp_pwd(cmd,state); break;
case MKD: ftp_mkd(cmd,state); break;
case RMD: ftp_rmd(cmd,state); break;
case RETR: ftp_retr(cmd,state); break;
case STOR: ftp_stor(cmd,state); break;
case DELE: ftp_dele(cmd,state); break;
case SIZE: ftp_size(cmd,state); break;
case ABOR: ftp_abor(state); break;
case QUIT: ftp_quit(state); break;
case TYPE: ftp_type(cmd,state); break;
case CDUP: ftp_cdup(state); break;
case HELP: ftp_help(cmd, state); break;
case NLST: ftp_nlst(cmd, state); break;
case RNFR: ftp_rnfr(cmd, state); break;
case RNTO: ftp_rnto(cmd, state); break;
case APPE: ftp_appe(cmd, state); break;
case NOOP:
if(state->logged_in){
state->message = "200 Zzz...\n";
}else{
state->message = "530 Please login with USER and PASS\n";
}
write_state(state);
break;
default:
state->message = "500 Unknown command\n";
write_state(state);
break;
}
}
void help_cmd(const char *service, User *u, Command *list, const char *cmd)
{
Command *c = lookup_cmd(list, cmd);
if (c)
{
if (c->helpmsg_syntax || c->helpmsg_help || c->helpmsg_example)
{
if (c->helpmsg_syntax)
notice_help(service, u, c->helpmsg_syntax );
if (c->helpmsg_help)
notice_help(service, u, c->helpmsg_help );
if (c->helpmsg_example)
notice_help(service, u, c->helpmsg_example );
}
else
{
notice_lang(service, u, NO_HELP_AVAILABLE, cmd);
}
} else {
notice_lang(service, u, NO_HELP_AVAILABLE, cmd);
}
}
static void
add_setshow_generic (enum var_types param_type, enum command_class cmd_class,
char *cmd_name, param_smob *self,
char *set_doc, char *show_doc, char *help_doc,
cmd_const_sfunc_ftype *set_func,
show_value_ftype *show_func,
struct cmd_list_element **set_list,
struct cmd_list_element **show_list,
struct cmd_list_element **set_cmd,
struct cmd_list_element **show_cmd)
{
struct cmd_list_element *param = NULL;
const char *tmp_name = NULL;
switch (param_type)
{
case var_boolean:
add_setshow_boolean_cmd (cmd_name, cmd_class,
&self->value.intval,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list);
break;
case var_auto_boolean:
add_setshow_auto_boolean_cmd (cmd_name, cmd_class,
&self->value.autoboolval,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list);
break;
case var_uinteger:
add_setshow_uinteger_cmd (cmd_name, cmd_class,
&self->value.uintval,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list);
break;
case var_zinteger:
add_setshow_zinteger_cmd (cmd_name, cmd_class,
&self->value.intval,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list);
break;
case var_zuinteger:
add_setshow_zuinteger_cmd (cmd_name, cmd_class,
&self->value.uintval,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list);
break;
case var_zuinteger_unlimited:
add_setshow_zuinteger_unlimited_cmd (cmd_name, cmd_class,
&self->value.intval,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list);
break;
case var_string:
add_setshow_string_cmd (cmd_name, cmd_class,
&self->value.stringval,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list);
break;
case var_string_noescape:
add_setshow_string_noescape_cmd (cmd_name, cmd_class,
&self->value.stringval,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list);
break;
case var_optional_filename:
add_setshow_optional_filename_cmd (cmd_name, cmd_class,
&self->value.stringval,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list);
break;
case var_filename:
add_setshow_filename_cmd (cmd_name, cmd_class,
&self->value.stringval,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list);
break;
case var_enum:
add_setshow_enum_cmd (cmd_name, cmd_class,
self->enumeration,
&self->value.cstringval,
set_doc, show_doc, help_doc,
set_func, show_func,
set_list, show_list);
/* Initialize the value, just in case. */
self->value.cstringval = self->enumeration[0];
break;
default:
gdb_assert_not_reached ("bad param_type value");
}
/* Lookup created parameter, and register Scheme object against the
parameter context. Perform this task against both lists. */
tmp_name = cmd_name;
param = lookup_cmd (&tmp_name, *show_list, "", 0, 1);
gdb_assert (param != NULL);
set_cmd_context (param, self);
*set_cmd = param;
tmp_name = cmd_name;
param = lookup_cmd (&tmp_name, *set_list, "", 0, 1);
gdb_assert (param != NULL);
set_cmd_context (param, self);
*show_cmd = param;
}
static void unix_server_loop(void)
{
int ret;
str cmd, buffer;
static char buf[UNIXSOCK_BUF_SIZE];
struct unixsock_cmd* c;
while(1) {
reply_addr_len = sizeof(reply_addr);
ret = recvfrom(rx_sock, buf, UNIXSOCK_BUF_SIZE, 0,
(struct sockaddr*)&reply_addr, &reply_addr_len);
if (ret == -1) {
LOG(L_ERR, "unix_server_loop: recvfrom: (%d) %s\n",
errno, strerror(errno));
if ((errno == EINTR) ||
(errno == EAGAIN) ||
(errno == EWOULDBLOCK) ||
(errno == ECONNREFUSED)) {
DBG("unix_server_loop: Got %d (%s), going on\n",
errno, strerror(errno));
continue;
}
LOG(L_CRIT, "BUG: unix_server_loop: unexpected recvfrom error\n");
continue;
}
buffer.s = buf;
buffer.len = ret;
unixsock_reply_reset();
if (parse_cmd(&cmd, &buffer) < 0) {
unixsock_reply_asciiz("400 First line malformed\n");
unixsock_reply_send();
continue;
}
buffer.s = cmd.s + cmd.len + 1;
buffer.len -= cmd.len + 1 + 1;
skip_line(&buffer); /* Skip the reply filename */
c = lookup_cmd(&cmd);
if (c == 0) {
LOG(L_ERR, "unix_server_loop: Could not find "
"command '%.*s'\n", cmd.len, ZSW(cmd.s));
unixsock_reply_printf("500 Command %.*s not found\n", cmd.len, ZSW(cmd.s));
unixsock_reply_send();
continue;
}
ret = c->f(&buffer);
if (ret < 0) {
LOG(L_ERR, "unix_server_loop: Command '%.*s' failed with "
"return value %d\n", cmd.len, ZSW(cmd.s), ret);
/* Note that we do not send reply here, the
* function is supposed to do so, it knows the
* reason of the failure better than us
*/
}
}
}
