cs_boolean cgi_cs_do_authorization(char *puser, char *passwd)
{
cs_boolean is_authorized = FALSE;
db_ctc_user_t admin;
db_ctc_user_t user;
memset(&admin,0x00,sizeof(admin));
db_read(DB_CTC_ADMIN_INFO_ID,(cs_uint8*) &admin,sizeof(admin));
memset(&user,0x00,sizeof(user));
db_read(DB_CTC_USER_INFO_ID,(cs_uint8*) &user,sizeof(user));
if ((strcmp(user.usr,puser) == 0)
&& (strcmp(user.pwd, passwd) == 0))
{
is_authorized = TRUE;
g_current_account = CGI_CTC_USER;
}
if ((strcmp(admin.usr,puser) == 0)
&& (strcmp(admin.pwd, passwd) == 0))
{
is_authorized = TRUE;
g_current_account = CGI_CTC_ADMIN;
}
return is_authorized;
}
int mod_load(char *name, Function * f2, struct global_t * g2) {
struct db_row_t row;
f = f2;
context();
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_DEBUG, "module %s loading", name);
g2->mysql_dbh = mysql_init(NULL);
mysql_options(g2->mysql_dbh, MYSQL_READ_DEFAULT_GROUP, g2->mysql_db);
if (!mysql_real_connect(g2->mysql_dbh, g2->mysql_host, g2->mysql_user, g2->mysql_pass, g2->mysql_db, 0, NULL, 0)) {
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_CRITICAL, "%s: failed to connect to database: %s", name, mysql_error(g2->mysql_dbh));
g2->mysql_connected = 0;
} else {
g2->mysql_connected = 1;
row = db_read("SELECT COUNT(nick) FROM rb.users");
if (row.num_fields >= 1)
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_INFO, "%s: total users: %d", name, (int) atoi(row.r[0]));
db_row_clean(row);
row = db_read("SELECT COUNT(crc) FROM rb.csvs");
if (row.num_fields >= 1)
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_INFO, "%s: total files: %d", name, (int) atoi(row.r[0]));
db_row_clean(row);
}
return (MODULE_HOOK_EVERY20SEC);
}
/* Match pattern against files in locate.db file */
static int
db_locate(
const wchar_t *pattern)
{
int count = 0;
#ifdef WIN32
wchar_t buffer[PATH_MAX + 1];
/* Open locate.db for read */
db_open ();
/* Read one directory and file name at a time from database file */
while (db_read (buffer, PATH_MAX)) {
/* See if file name in buffer matches the search pattern */
if (db_match (buffer, pattern)) {
/* Match found => output file name and path */
wprintf (L"%s\n", buffer);
count++;
}
}
db_close ();
#endif
return count;
}
cs_status app_ipintf_outband_enable()
{
cs_status ret = CS_E_OK;
db_zte_mgmt_t mgmt_info;
memset(&mgmt_info,0x00,sizeof(mgmt_info));
db_read(DB_ZTE_MGMT_INFO_ID,(cs_uint8*) &mgmt_info,sizeof(mgmt_info));
if(APP_IPINTF_OUTBNAD_MGNT == mgmt_info.inband_enable) {
APP_IPINTF_LOG(IROS_LOG_LEVEL_INF,"No need set to OUTBAND \n");
return CS_E_OK;
}
ret = app_ipintf_ip_config_set(
mgmt_info.ip,
mgmt_info.mask,
0);
if(ret != CS_E_OK) {
return ret;
}
ret = app_ipintf_set_wan_cfg(
APP_IPINTF_OUTBNAD_MGNT,
mgmt_info.inband_pri,
mgmt_info.inband_vlan,
mgmt_info.mgmt_net,
mgmt_info.mgmt_mask);
APP_IPINTF_LOG(IROS_LOG_LEVEL_INF,"Set to OUTBAND \n");
return ret;
}
int
main(int argc, char **argv)
{
int i;
if (argc != 3) {
fprintf(stderr, "Must be called in form 'extract <filename> <dbref>'\n");
exit(1);
}
if ((input_file = fopen(argv[1], "r")) == NULL) {
fprintf(stderr, "Could not open file '%d'\n", argv[1]);
exit(1);
}
me = atoi(argv[2]);
db_free();
db_read(input_file);
fprintf(stderr, "dbtop = %d\n", db_top);
printf("MUCK 2.2fb extract for dbref #%d\n", me);
for (i = 0; i < db_top; i++) {
if (OWNER(i) != me)
continue;
if (!(i % 256))
fprintf(stderr, "Checking object %d..\n", i);
check_common(i);
switch (db[i].flags & TYPE_MASK) {
case TYPE_ROOM:
check_room(i);
break;
case TYPE_THING:
check_thing(i);
break;
case TYPE_EXIT:
check_exit(i);
break;
case TYPE_PLAYER:
check_player(i);
break;
case TYPE_PROGRAM:
check_program(i);
break;
case TYPE_GARBAGE:
break;
default:
break;
}
}
fclose(input_file);
fprintf(stderr, "Completed extract normally.\n");
return 0;
}
/*****************************************************************
Function Name: main
Description: This is a main function
Parameter:
@argc: argument count
@argv: argument vector
Author: SA12226114(Xin Zhu), SA12226139(Dan Shu)
Date: 2012-11-27
******************************************************************/
int main(int argc, char *argv[])
{
void *db = NULL;
char cmdline[CMDLINE_LEN], cmd[CMD_LEN], key[KEY_LEN], value[VALUE_LEN];
/* display menu */
util_menu();
while(1)
{
/* format command line */
util_format(cmdline, cmd, key, value);
if(strncmp(cmd, "open", sizeof("open")) == 0) /* create database */
{
db_create(&db, key);
}
else if(strncmp(cmd, "set", sizeof("set")) == 0) /* store records */
{
db_write(db, key, value);
}
else if(strncmp(cmd, "get", sizeof("get")) == 0) /* retrieve records */
{
db_read(db, key);
}
else if(strncmp(cmd, "remove", sizeof("remove")) == 0) /* remove a record */
{
db_remove(db, key);
}
else if(strncmp(cmd, "ls", sizeof("ls")) == 0) /* dump all records in database */
{
db_queryallrecords(db);
}
else if(strncmp(cmd, "close", sizeof("close")) == 0) /* close the database */
{
db_close(&db);
}
else if(strncmp(cmd, "delete", sizeof("delete")) == 0) /* delete the object */
{
db_delete(&db);
}
else if(strncmp(cmd, "help", sizeof("help")) == 0) /* display menu info */
{
util_menu();
}
else if(strncmp(cmd, "quit", sizeof("quit")) == 0) /* quit system */
{
return;
}
}
return 0;
}
int
init_game(const char *infile, const char *outfile)
{
FILE *f;
if ((f = fopen(MACRO_FILE, "rb")) == NULL)
log_status("INIT: Macro storage file %s is tweaked.", MACRO_FILE);
else {
macroload(f);
fclose(f);
}
in_filename = (char *) string_dup(infile);
if ((input_file = fopen(infile, "rb")) == NULL)
return -1;
#ifdef DELTADUMPS
if ((delta_outfile = fopen(DELTAFILE_NAME, "wb")) == NULL)
return -1;
if ((delta_infile = fopen(DELTAFILE_NAME, "rb")) == NULL)
return -1;
#endif
db_free();
init_primitives(); /* init muf compiler */
mesg_init(); /* init mpi interpreter */
SRANDOM(getpid()); /* init random number generator */
tune_load_parmsfile(NOTHING); /* load @tune parms from file */
/* ok, read the db in */
log_status("LOADING: %s", infile);
fprintf(stderr, "LOADING: %s\n", infile);
if (db_read(input_file) < 0)
return -1;
log_status("LOADING: %s (done)", infile);
fprintf(stderr, "LOADING: %s (done)\n", infile);
/* set up dumper */
if (dumpfile)
free((void *) dumpfile);
dumpfile = alloc_string(outfile);
if (!db_conversion_flag) {
/* initialize the _sys/startuptime property */
add_property((dbref) 0, "_sys/startuptime", NULL, (int) time((time_t *) NULL));
add_property((dbref) 0, "_sys/maxpennies", NULL, tp_max_pennies);
add_property((dbref) 0, "_sys/dumpinterval", NULL, tp_dump_interval);
add_property((dbref) 0, "_sys/max_connects", NULL, 0);
}
return 0;
}
int domain_cant_print_screen(struct domain *d)
{
char tmp[1024];
char path[1024];
int rc = 0;
if (d)
{
sprintf(path, "/vm/%s/policies/print-screen-disallowed", d->uuid);
rc = db_read(tmp, 1024, path) && strcmp(tmp, "true") == 0;
info("print-screen path:%s value:%s disallow:%d", path, tmp, rc);
}
return rc;
}
void cgi_cs_get_cookie_str(char *cokieStr)
{
cs_uint8 usr[DB_CTC_MAX_USR_LEN + 1];
db_ctc_user_t admin;
db_ctc_user_t user;
memset(&admin,0x00,sizeof(admin));
db_read(DB_CTC_ADMIN_INFO_ID,(cs_uint8*) &admin,sizeof(admin));
memset(&user,0x00,sizeof(user));
db_read(DB_CTC_USER_INFO_ID,(cs_uint8*) &user,sizeof(user));
if(g_current_account == CGI_CTC_ADMIN)
{
strncpy(usr, admin.usr, DB_CTC_MAX_USR_LEN);
}
else
{
strncpy(usr, user.usr, DB_CTC_MAX_USR_LEN);
}
sprintf(cokieStr, "user=%s|%s|%s|none|0;", usr,admin.usr, user.usr);
}
static int
domain_read_slot(struct domain *d)
{
char slot_str[10];
char path[128];
int rc = 0;
sprintf(path, "/vm/%s/slot", d->uuid);
rc = db_read(slot_str, 1, path);
if (rc != TRUE)
return -1;
return strtol(slot_str, NULL, 10);
}
cgi_status cgi_cs_user_account_get(
cs_uint8 *usr,
cs_uint8 *pwd)
{
db_ctc_user_t user;
CGI_ASSERT_RET((NULL != usr
&&(NULL != pwd)), CGI_ERROR_PARAM);
memset(&user,0x00,sizeof(user));
db_read(DB_CTC_USER_INFO_ID,(cs_uint8*) &user,sizeof(user));
strncpy(usr, user.usr, DB_CTC_MAX_USR_LEN);
strncpy(pwd, user.pwd, DB_CTC_MAX_PWD_LEN);
return CGI_OK;
}
cgi_status cgi_cs_admin_account_get(
cs_uint8 *usr,
cs_uint8 *pwd)
{
db_ctc_user_t admin;
CGI_ASSERT_RET((NULL != usr
&&(NULL != pwd)), CGI_ERROR_PARAM);
memset(&admin,0x00,sizeof(admin));
db_read(DB_CTC_ADMIN_INFO_ID,(cs_uint8*) &admin,sizeof(admin));
strncpy(usr, admin.usr, DB_CTC_MAX_USR_LEN);
strncpy(pwd, admin.pwd, DB_CTC_MAX_PWD_LEN);
return CGI_OK;
}
static void
domain_read_has_secondary_gpu(struct domain *d)
{
char gpu_db_str[128];
char gpu;
int rc = 0;
d->has_secondary_gpu = 0;
if (d->is_pvm)
return;
sprintf(gpu_db_str, "/vm/%s/gpu", d->uuid);
rc = db_read(&gpu, 1, gpu_db_str);
if (rc != TRUE)
return;
d->has_secondary_gpu = (gpu != 0);
}
cgi_status cgi_cs_port_config_set(cgi_handler_param_t * p)
{
cs_uint8 port, admin,auto_neg,mode, pause,loopback,isolation;
cs_uint32 mac;
cs_status ret = CS_E_OK;
cs_callback_context_t context;
db_ctc_port_t port_info;
if(CS_E_OK != cgi_get_int8_by_key(p,"port",&port)
|| CS_E_OK != cgi_get_int8_by_key(p,"phy",&admin)
|| CS_E_OK != cgi_get_int8_by_key(p,"mode",&mode)
|| CS_E_OK != cgi_get_int8_by_key(p, "isolation", &isolation)
|| CS_E_OK != cgi_get_int32_by_key(p, "mac", &mac)
|| CS_E_OK != cgi_get_int8_by_key(p,"pause",&pause)
|| CS_E_OK != cgi_get_int8_by_key(p, "loopback", &loopback)){
CGI_LOG("get parameters failed from URL");
cgi_send_int(p,CGI_ERROR_PARAM);
return CS_E_ERROR;
}
CGI_DEBUG("port = %d ,admin = %d ,mode = %d ,isolation = %d ,mac = %d ,pause = %d ,loopback = %d\n",
port,admin,mode,isolation,mac,pause,loopback);
ret = epon_request_onu_port_admin_set(context,
ONU_DEVICEID_FOR_API, ONU_LLIDPORT_FOR_API, port, admin);
if(ret != CS_E_OK){
CGI_LOG("set port admin status failed ,ret = %d \n",ret);
cgi_send_int(p,CGI_SDL_FAILED);
return CS_E_ERROR;
}
if(mode == 0) {
auto_neg = 1;
} else {
auto_neg = 0;
}
ret = cgi_cs_port_auto_set(port,auto_neg);
if(ret != CS_E_OK){
CGI_LOG("set port auto status failed ,ret = %d \n",ret);
cgi_send_int(p,CGI_SDL_FAILED);
return CS_E_ERROR;
}
ret = cgi_cs_port_work_mode_set(port,mode);
if(ret != CS_E_OK){
CGI_LOG("set port working mode failed ,ret = %d \n",ret);
cgi_send_int(p,CGI_SDL_FAILED);
return CS_E_ERROR;
}
ret = epon_request_onu_port_isolation_set(context,
ONU_DEVICEID_FOR_API, ONU_LLIDPORT_FOR_API,isolation);
if(ret != CS_E_OK){
CGI_LOG("set port isolation failed, ret =%d \n", ret);
cgi_send_int(p, CGI_SDL_FAILED);
return CS_E_ERROR;
}
ret = epon_request_onu_port_mac_learn_set(context,
ONU_DEVICEID_FOR_API, ONU_LLIDPORT_FOR_API, port, mac);
if(ret != CS_E_OK){
CGI_LOG("set port max mac learning failed, ret=%d \n", ret);
cgi_send_int(p, CGI_SDL_FAILED);
return CS_E_ERROR;
}
ret = epon_request_onu_port_flow_ctrl_set(context,
ONU_DEVICEID_FOR_API, ONU_LLIDPORT_FOR_API, port, pause);
if(ret != CS_E_OK){
CGI_LOG("set port pause failed ,ret = %d \n",ret);
cgi_send_int(p,CGI_SDL_FAILED);
return CS_E_ERROR;
}
ret = epon_request_onu_port_lpbk_set(context,
ONU_DEVICEID_FOR_API, ONU_LLIDPORT_FOR_API, port, loopback);
if(ret != CS_E_OK){
CGI_LOG("set port loopback failed, ret = %d \n",ret);
cgi_send_int(p,CGI_SDL_FAILED);
return CS_E_ERROR;
}
memset(&port_info,0x00,sizeof(port_info));
db_read(DB_CTC_PORT_INFO_ID,(cs_uint8 *) &port_info, sizeof(port_info));
port_info.port[port - 1].admin= admin;
port_info.port[port - 1].auto_neg = auto_neg;
switch (mode) {
case CGI_CTC_PORT_MODE_AUTO:
port_info.port[port - 1].work_mode = SDL_PORT_AUTO_10_100_1000;
break;
case CGI_CTC_PORT_MODE_10M_HALF:
port_info.port[port - 1].work_mode = SDL_PORT_10_HALF;
break;
case CGI_CTC_PORT_MODE_10M_FULL:
port_info.port[port - 1].work_mode = SDL_PORT_10_FULL;
break;
case CGI_CTC_PORT_MODE_100M_HALF:
port_info.port[port - 1].work_mode = SDL_PORT_100_HALF;
break;
case CGI_CTC_PORT_MODE_100M_FULL:
port_info.port[port - 1].work_mode = SDL_PORT_100_FULL;
break;
case CGI_CTC_PORT_MODE_1000M_FULL:
port_info.port[port - 1].work_mode = SDL_PORT_1000_FULL;
break;
default:
return CS_E_PARAM;
}
port_info.port[port - 1].pause = pause;
db_write(DB_CTC_PORT_INFO_ID,(cs_uint8 *) &port_info, sizeof(port_info));
cs_thread_delay(2000);
cgi_send_int(p,CGI_OK);
return CS_E_OK;
}
int
cddbd_submit(FILE *fp, email_hdr_t *eh, int flags, char *errstr)
{
int i;
int len;
int ret;
int dbflags;
db_t *db;
char buf[CDDBBUFSIZ];
char buf2[CDDBBUFSIZ];
struct stat sbuf;
/* Set the interface type. */
interface = IF_SUBMIT;
if(!(flags & MF_TEST))
hperm = *ck_host_perms(interface);
if((ret = validate_email(fp, eh, errstr)) != EE_OK)
return ret;
if(!WRITE_OK(hperm) && !(flags & MF_TEST)) {
cddbd_snprintf(errstr, CDDBBUFSIZ,
"Email submissions disallowed");
return EE_ERROR;
}
if(categ_index(eh->eh_category) < 0) {
cddbd_snprintf(errstr, CDDBBUFSIZ, "Invalid DB category: %s\n"
"Valid categories are:", eh->eh_category);
for(i = 0, len = strlen(errstr); categlist[i] != 0; i++) {
cddbd_snprintf(&errstr[len], (CDDBBUFSIZ - len),
" %s", categlist[i]);
len += strlen(categlist[i]) + 1;
}
return EE_ERROR;
}
/* Specify acceptable charsets. */
dbflags = charsets[eh->eh_charset].df_flags;
if((dbflags & DF_ENC_LATIN1) && utf_as_iso == UAI_CONVERT)
dbflags |= DF_ENC_UTF8;
if(!(flags & MF_TEST))
dbflags |= DF_CK_SUBMIT;
rewind(fp);
db = db_read(fp, buf, (DF_MAIL | DF_SUBMITTER | dbflags));
if(db == 0) {
cddbd_snprintf(errstr, CDDBBUFSIZ, "Invalid DB submission: %s",
buf);
return EE_ERROR;
}
/* Check and disambiguate charset. */
if (db_disam_charset(db)) {
cddbd_snprintf(errstr, CDDBBUFSIZ,
"Entry rejected: looks like UTF-8.");
return EE_ERROR;
}
if(!(flags & MF_TEST)) {
/* Check for postdir, and create if it doesn't exist. */
if(stat(postdir, &sbuf)) {
if(mkdir(postdir, (mode_t)db_dir_mode)) {
cddbd_log(LOG_ERR,
"Failed to create post dir %s.", postdir);
cddbd_snprintf(errstr, CDDBBUFSIZ,
"Internal server file error");
return EE_ERROR;
}
(void)cddbd_fix_file(postdir, db_dir_mode, db_uid, db_gid);
}
else if(!S_ISDIR(sbuf.st_mode)) {
cddbd_log(LOG_ERR, "%s is not a directory.", postdir);
cddbd_snprintf(errstr, CDDBBUFSIZ,
"Internal server file error");
return EE_ERROR;
}
cddbd_snprintf(buf2, sizeof(buf), "%s/%s",
postdir, eh->eh_category);
/* zeke - add eh info to db struct for writing to post entry */
db->db_eh.eh_flags = eh->eh_flags;
db->db_eh.eh_charset = eh->eh_charset;
db->db_eh.eh_encoding = eh->eh_encoding;
strcpy (db->db_eh.eh_to, eh->eh_to);
strcpy (db->db_eh.eh_rcpt, eh->eh_rcpt);
strcpy (db->db_eh.eh_host, eh->eh_host);
/* end zeke */
if(!db_post(db, buf2, eh->eh_discid, buf)) {
if(db_errno != DE_INVALID) {
cddbd_snprintf(errstr, CDDBBUFSIZ,
"Internal DB server error: %s", buf);
}
else
cddbd_snprintf(errstr, CDDBBUFSIZ,
"Invalid DB file: %s", buf);
return EE_ERROR;
}
cddbd_log(LOG_INFO | LOG_WRITE,
"Write (via SMTP - %s): %s %08x", eh->eh_to,
eh->eh_category, eh->eh_discid);
}
else {
cddbd_log(LOG_INFO, "Test email submission (from %s): %s %08x",
eh->eh_to, eh->eh_category, eh->eh_discid);
}
return EE_OK;
}
int ag_db_read(unsigned dbh, char *key, int lock)
{ return db_read(h2p(dbh),key,lock);
}
void db_exec(char cmd[])
{
uint32_t tmp;
uint32_t i, pos;
uint32_t len = strlen(cmd);
bool is_valid = false;
char name[CMD_BUF_LEN];
uint8_t data[CMD_BUF_LEN];
switch(cmd[0]) {
case 'h':
for(i = 2; i < NAME_MAX_LEN; i++) {
if('=' == cmd[i]) {
is_valid = true;
cmd[i] = 0;
break;
}
}
if(is_valid) {
for(i = 0; 0 != cmd[i + 1]; i++) {
name[i] = cmd[i + 1];
}
sscanf(cmd + 2 + i, "%32x", &tmp);
db_save(name, (uint8_t*)(&tmp), sizeof(uint32_t));
tmp = 0;
db_read(name, (uint8_t*)(&tmp));
printf("\nname:%s\nhex:0x%x saved.\n", name, tmp);
} else {
printf("\nInvalid hex\n");
}
break;
case 'w':
for(i = 1; i < NAME_MAX_LEN; i++) {
if('=' == cmd[i]) {
is_valid = true;
cmd[i] = 0;
break;
}
}
if(is_valid) {
for(i = 1; cmd[i] != 0; i++) {
name[i - 1] = cmd[i];
}
name[i - 1] = 0;
pos = i + 1;
for(i = 0; '\n' != cmd[pos + i]; i++) {
data[i] = cmd[pos + i];
}
data[i] = 0;
printf("\nname:%s,data:%s\n", (char*)name, (char*)data);
db_save((char*)name, data, i);
} else {
printf("\nWrong code to write\n");
}
break;
case 'r':
for(i = 1; i < NAME_MAX_LEN; i++) {
name[i - 1] = cmd[i];
if('\n' == cmd[i]) {
name[i - 1] = 0;
break;
}
}
db_read((char*)name, data);
printf("\n%s=%s\n", name, data);
break;
case 'd':
for(i = 1; i < NAME_MAX_LEN; i++) {
name[i - 1] = cmd[i];
if('\n' == cmd[i]) {
name[i - 1] = 0;
break;
}
}
db_delete((char*)name);
printf("\n%s deleted\n", name);
break;
case 's':
db_sync();
printf("\nsync done\n");
break;
default:
#ifdef DEBUG_DB_EXEC
printf("\nUnrecognised code\n");
#endif
break;
}
}
int mod_ircinput(char *fullline, char *part2, char *part3, char *part4, char *part5, struct global_t * g2) {
unsigned int j = 1;
context();
if (!strcasecmp(part2, "NICK") && part3) {
char *newnick, *oldnick;;
oldnick = (char *) mycalloc(TEXTLENGTH_STD);
while (fullline[j] != '!' && j < strlen(fullline) && (j < (TEXTLENGTH_STD - 1))) {
oldnick[j - 1] = fullline[j];
j++;
}
oldnick[j - 1] = '\0';
newnick = part3;
if (newnick[0] == ':')
newnick++;
if (!strcasecmp(oldnick, g2->user_nick)) {
free(g2->user_nick);
g2->user_nick = (char *)calloc(1,TEXTLENGTH_STD); //allocated by libconfig
strncpy(g2->user_nick, newnick, TEXTLENGTH_STD);
} else { /* someone else changed nicks */
if (db_write("UPDATE %s.%s SET user='******' WHERE user='******'", g2->mysql_db, g2->mysql_table_irc_users, newnick, oldnick))
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "nick.so: user missed %s -> %s", oldnick, newnick);
}
mydelete(oldnick);
return (T_OK);
} else if (!strcasecmp(part2, "MODE") && part3 && part4 && part5) { //mode change
// WARNING: mode change (:[email protected] MODE #ANTHALIA.COM +oo Heimy ifsnopALS ) (MODE) (#ANTHALIA.COM) (+oo)
int channelid = -1;
context();
for (j = 0; j < g2->irc_channel_count; j++) {
if (!strcasecmp(g2->irc_channel[j], part3)) {
channelid = j;
break;
}
}
if (channelid > -1) {
if (strlen(part4) >= 2) {
char *ptr;
int k = 1, umode = USER_MODE_HAS_0;
struct db_row_t row;
while (part4[k] != '\0') {
ptr = getpart(fullline, k + 4);
if (part4[k] == 'l' || part4[k] == 'b')
goto next;
if (part4[k] == 'o')
umode = USER_MODE_HAS_OP;
if (part4[k] == 'v')
umode = USER_MODE_HAS_V;
row = db_read("SELECT mode FROM %s.%s WHERE channelid = '%d' AND user = '******'", g2->mysql_db, g2->mysql_table_irc_users, channelid, ptr);
if ( row.num_fields >= 1 ) {
if (part4[0] == '+') {
umode |= atoi(row.r[0]);
} else {
if (part4[0] == '-')
umode ^= atoi(row.r[0]);
}
if (db_write("UPDATE %s.%s SET mode = '%d' WHERE channelid = '%d' AND user = '******'", g2->mysql_db, g2->mysql_table_irc_users, umode, channelid, ptr))
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "nick.so: problem changing user mode %s %c", ptr, umode);
} else {
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "nick.so: problem finding user %s", ptr);
}
db_row_clean(row);
next:
mydelete(ptr);
k++;
}
}
} else
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "nick.so: problem changing user mode, channel not found %s", part5);
return (T_OK);
} else if (!strcmp(part2, "PART") && part3) {
char *nick;
int channelid = -1;
context();
nick = (char *) mycalloc(TEXTLENGTH_STD);
while ( (fullline[j] != '!') && (j < strlen(fullline)) && (j < (TEXTLENGTH_STD -1)) ) {
nick[j - 1] = fullline[j];
j++;
}
nick[j - 1] = '\0';
if ( !strcasecmp(nick, g2->user_nick) ) {
// we left, funny, why?
} else {
char *t3;
t3 = part3;
if (t3[0] == ':')
t3++;
for (j = 0; j < g2->irc_channel_count; j++) {
if (!strcasecmp(g2->irc_channel[j], t3)) {
channelid = j;
break;
}
}
if (channelid > -1) {
if ( db_write("DELETE FROM %s.%s WHERE channelid = '%d' AND user = '******'", g2->mysql_db, g2->mysql_table_irc_users, channelid, nick) )
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "nick.so: error deleting (%s) from (%d)(%s)", nick, channelid, t3);
} else
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "nick.so: someone (%s) leave a not known channel (%s)", nick, t3);
}
mydelete(nick);
return (T_OK);
} else if (!strcasecmp(part2, "JOIN") && part3) {
int channelid = -1;
char *nick;
context();
nick = (char *) mycalloc(TEXTLENGTH_STD);
while ( (fullline[j] != '!') && (j < strlen(fullline)) && (j < (TEXTLENGTH_STD - 1)) ) {
nick[j - 1] = fullline[j];
j++;
}
nick[j - 1] = '\0';
if (part3[0] == ':') {
for (j = 1; j <= strlen(part3); j++)
part3[j - 1] = part3[j];
part3[j] = '\0'; // lets ensure that part3 aka channel is #channelname, and not :#channel or whatever.
}
if ( !strcasecmp(nick, g2->user_nick) ) {
// we joined
for (j = 0; j < g2->irc_channel_count; j++) {
if (!strcasecmp(g2->irc_channel[j], part3)) {
g2->irc_channel_joined[j] = 'Y';
channelid = j;
break;
}
}
if (channelid == -1)
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "nick.so: joined (%s) which is not a known channel", part3);
/* else {
if ( db_write("DELETE FROM irc_users WHERE channelid = '%d'", channelid) )
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "nick.so: can't delete userlist from (%d)(%s)", channelid, part3);
}*/ //redundante, al hacer un join ya se ha hecho un delete previo
} else { //someone else joined
for (j = 0; j < g2->irc_channel_count; j++) {
if (!strcasecmp(g2->irc_channel[j], part3)) {
channelid = j;
break;
}
}
if (channelid > -1) {
if (db_write("INSERT INTO %s.%s (channelid, user, mode) VALUES ('%d', '%s', '%d')", g2->mysql_db, g2->mysql_table_irc_users, channelid, nick, 0)) {
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "nick.so: error adding (%s) to (%s) ", nick, part3);
}
} else {
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "nick.so: someone (%s) joined (%s) which is not a known channel", nick, part3);
}
}
mydelete(nick);
return (T_OK);
} else if (!strcmp(part2, "QUIT")) {
char *nick;
context();
nick = (char *) mycalloc(TEXTLENGTH_STD);
while ( (fullline[j] != '!') && ( j < strlen(fullline)) && (j < (TEXTLENGTH_STD - 1)) ) {
nick[j - 1] = fullline[j];
j++;
}
nick[j - 1] = '\0';
if (!strcasecmp(nick, g2->user_nick)) {
// we leave? funny
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_INFO, "nick.so: we leave");
} else {
if ( db_write("DELETE FROM %s.%s WHERE user = '******'", g2->mysql_db, g2->mysql_table_irc_users, nick) )
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "nick.so: error deleting (%s)", nick);
}
mydelete(nick);
} else if (!strcmp(part2, "KICK") && part3 && part4) {
int channelid = -1;
context();
for (j = 0; j < g2->irc_channel_count; j++) {
if (!strcasecmp(g2->irc_channel[j], part3)) {
channelid = j;
break;
}
}
if (channelid > -1) {
if (!strcasecmp(part4, g2->user_nick)) {
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_INFO, "nick.so: kicked from %s, rejoining", part3);
g2->irc_channel_joined[channelid] = 'N';
} else {
if ( db_write("DELETE FROM %s.%s WHERE user = '******' AND channelid = '%d'", g2->mysql_db, g2->mysql_table_irc_users, part4, channelid) )
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "nick.so: error deleting kicked (%s) from (%d)(%s)", part4, channelid, part3);
}
} else
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "nick.so: kick to (%s) on a not known channel (%s)", part4, part3);
return (T_OK);
} else if (!strcmp(part2, "353") && part3 && part4 && part5) {
/* names list for a channel */
/* :server 353 our_nick = #channel :nick @nick +nick nick */
char *t, *t2;
int i;
int channelid = -1;
context();
for (j = 0; j < g2->irc_channel_count; j++) {
if (!strcasecmp(g2->irc_channel[j], part5)) {
channelid = j;
break;
}
}
if (channelid > -1) {
for (i = 0; (t2 = t = getpart(fullline, 6 + i)) ; i++) {
int umode = USER_MODE_HAS_0;
if (t[0] == ':') { umode |= USER_MODE_HAS_0; t++; }
if (t[0] == '@') { umode |= USER_MODE_HAS_OP; t++; }
if (t[0] == '+') { umode |= USER_MODE_HAS_V; t++; }
if (t[0] == '@') { umode |= USER_MODE_HAS_OP; t++; }
if (db_write("INSERT INTO %s.%s (channelid, user, mode) VALUES ('%d', '%s', '%d')", g2->mysql_db, g2->mysql_table_irc_users, channelid, t, umode))
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "nick.so: problem inserting user (%s)", t);
mydelete(t2);
}
} else {
ioutput(OUTPUT_DEST_LOG | OUTPUT_TYPE_WARN, "nick.so: userlist from unknown channel (%s)", part5);
}
return (T_OK);
} else {
return (T_IGNORE);
}
return (T_IGNORE);
}
int
main(int argc, char *argv[])
{
int setflags, clrflags, ver, nochk;
int db_ver, db_format, db_flags, do_check, do_write;
char *fp;
FILE *f_ptr;
char s_filename[120];
f_ptr = NULL;
nochk = 0;
if (argc == 3) {
for (fp = argv[2]; *fp; fp++) {
if (*fp == 'x') {
nochk = 1;
break;
}
}
}
if (!nochk) {
sprintf(s_filename, "%.115s.db", argv[1]);
if ( (f_ptr = fopen(s_filename, "r")) != NULL ) {
fprintf(stderr, "GDBM file(s) already exist for %s\n", s_filename);
fclose(f_ptr);
exit(1);
}
sprintf(s_filename, "%.115s.dir", argv[1]);
if ( (f_ptr = fopen(s_filename, "r")) != NULL ) {
fprintf(stderr, "GDBM file(s) already exist for %s\n", s_filename);
fclose(f_ptr);
exit(1);
}
sprintf(s_filename, "%.115s.pag", argv[1]);
if ( (f_ptr = fopen(s_filename, "r")) != NULL ) {
fprintf(stderr, "GDBM file(s) already exist for %s\n", s_filename);
fclose(f_ptr);
exit(1);
}
}
debugmem = (Debugmem *)malloc(sizeof(Debugmem));
if( !debugmem )
abort();
INITDEBUG(debugmem);
if ((argc < 2) || (argc > 3)) {
usage(argv[0]);
exit(1);
}
dddb_var_init();
cache_var_init();
cf_init();
/* Decide what conversions to do and how to format the output file */
setflags = clrflags = ver = do_check = 0;
do_write = 1;
if (argc == 3) {
for (fp = argv[2]; *fp; fp++) {
switch (*fp) {
case 'C':
do_check = 1;
break;
case 'G':
setflags |= V_GDBM;
break;
case 'g':
clrflags |= V_GDBM;
break;
case 'Z':
setflags |= V_ZONE;
break;
case 'z':
clrflags |= V_ZONE;
break;
case 'L':
setflags |= V_LINK;
break;
case 'l':
clrflags |= V_LINK;
break;
case 'N':
setflags |= V_ATRNAME;
break;
case 'n':
clrflags |= V_ATRNAME;
break;
case 'K':
setflags |= V_ATRKEY;
break;
case 'k':
clrflags |= V_ATRKEY;
break;
case 'P':
setflags |= V_PARENT;
break;
case 'p':
clrflags |= V_PARENT;
break;
case 'W':
do_write = 1;
break;
case 'w':
do_write = 0;
break;
case 'X':
clrflags = 0xffffffff;
setflags = OUTPUT_FLAGS;
ver = OUTPUT_VERSION;
break;
case 'x':
clrflags = 0xffffffff;
setflags = UNLOAD_OUTFLAGS;
ver = UNLOAD_VERSION;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
ver = ver * 10 + (*fp - '0');
break;
default:
fprintf(stderr, "Unknown flag: '%c'\n", *fp);
usage(argv[0]);
exit(1);
}
}
}
/* Open the gdbm file */
if (init_gdbm_db(argv[1]) < 0) {
fprintf(stderr, "Can't open GDBM file\n");
exit(1);
}
/* Go do it */
db_read(stdin, &db_format, &db_ver, &db_flags);
fprintf(stderr, "Input: ");
info(db_format, db_flags, db_ver);
val_count();
if (do_check)
do_dbck(NOTHING, NOTHING, DBCK_FULL);
if (do_write) {
db_flags = (db_flags & ~clrflags) | setflags;
if (db_format != F_MUSH)
db_ver = 3;
if (ver != 0)
db_ver = ver;
fprintf(stderr, "Output: ");
info(F_MUSH, db_flags, db_ver);
db_write(stdout, F_MUSH, db_ver | db_flags);
}
CLOSE;
return(0);
}
