/* Set the value. */
static void
printer_set (struct printer *p,
const char * ppdkey, const char * command)
{
xstrcpy (p->ppdkey, ppdkey);
xstrcpy (p->command, command);
}
/*****************************************************************************
* Devide full outbound path on "root" directory, there other oubound
* directories created, and main outbound directory name
*
* Arguments:
* path pointer to the null-terminated outbound path string
* out_root pointer to the pointer for the resulting root directory
* out_main pointer to the pointer for the resulting main outbound
* name w/o path
*
* Return value:
* Zero on success (*out_root and *out_main must be freed)
*/
int out_get_root(const char *path, char **out_root, char **out_main)
{
char *p, *outb;
ASSERT(path != NULL && out_root != NULL && out_main != NULL);
*out_root = NULL;
*out_main = NULL;
outb = (char *)xstrcpy(path);
p = outb + strlen(outb) - 1;
if( *p == DIRSEPCHR )
*p = '\0';
/* Ohh.. where is no full path for outbound directory */
if( (p=strrchr(outb, DIRSEPCHR)) == NULL )
{
free(outb);
return -1;
}
*p = '\0';
*out_main = xstrcpy(p+1);
*out_root = xstrcat(outb, "/");
DEB((D_OUTBOUND, "out_getroot: out_root \"%s\", out_main \"%s\"",
*out_root, *out_main));
return 0;
}
char* irc_get_mask(char *buf, char *raw) {
char *data;
char *seperateFrmSp;
char *mask;
if(buf == NULL)
return buf;
data = (char*)callocm(MAX_LEN, sizeof(char));
if(data == NULL)
return NULL;
xstrcpy(data, raw, MAX_LEN);
seperateFrmSp = xstrtok(data, " ", NULL);
if(seperateFrmSp == NULL) {
freem(data);
return NULL;
}
xstrcpy(data, seperateFrmSp, MAX_LEN);
mask = xstrtok(data, ":", NULL);
if(mask == NULL) {
freem(data);
return NULL;
}
strcpy(buf, mask);
freem(data);
return buf;
}
char* irc_get_nick(char *buf, char *raw) {
char *data;
char *seperateFrmCol;
char *nick;
if(buf == NULL)
return buf;
data = (char*)callocm(MAX_LEN, sizeof(char));
if(data == NULL)
return NULL;
xstrcpy(data, raw, MAX_LEN);
seperateFrmCol = xstrtok(data, ":", NULL);
if(seperateFrmCol == NULL) {
freem(data);
return NULL;
}
strcpy(data, seperateFrmCol);
if(strchr(data, '!') == NULL)
nick = xstrtok(data, " ", NULL);
else
nick = xstrtok(data, "!", NULL);
if(nick == NULL) {
freem(data);
return NULL;
}
xstrcpy(buf, nick, MAX_NICKLEN);
freem(data);
return buf;
}
/*
* Check for personal message
*/
void reg_ipm_r(char *data, char *buf)
{
char *name, *msg;
int rec;
pid_t pid;
buf[0] = '\0';
snprintf(buf, SS_BUFSIZE, "100:0;");
strtok(data, ",");
pid = (pid_t)atoi(strtok(NULL, ";"));
if ((rec = reg_find(pid)) == -1)
return;
reginfo[rec].lastcon = (int)time(NULL);
if (!reginfo[rec].ismsg)
return;
name = xstrcpy(clencode(reginfo[rec].fname[reginfo[rec].ptr_out]));
msg = xstrcpy(clencode(reginfo[rec].msg[reginfo[rec].ptr_out]));
snprintf(buf, SS_BUFSIZE, "100:2,%s,%s;", name, msg);
if (reginfo[rec].ptr_out < RB)
reginfo[rec].ptr_out++;
else
reginfo[rec].ptr_out = 0;
if (reginfo[rec].ptr_out == reginfo[rec].ptr_in)
reginfo[rec].ismsg = FALSE;
Syslog('+', "reg_ipm: in=%d out=%d ismsg=%d", reginfo[rec].ptr_in, reginfo[rec].ptr_out, reginfo[rec].ismsg);
free(name);
free(msg);
return;
}
char *xtodos(char *orig)
{
char buf[13], *copy, *p;
if (orig == NULL)
return NULL;
if ((remote_flags & SESSION_FNC) == 0) {
Syslog('o', "No filename conversion for \"%s\"", MBSE_SS(orig));
return xstrcpy(orig);
}
copy = xstrcpy(orig);
if ((p = strrchr(copy,'/')))
p++;
else
p = copy;
name_mangle(p);
memset(&buf, 0, sizeof(buf));
strncpy(buf, p, 12);
Syslog('o', "name \"%s\" converted to \"%s\"", MBSE_SS(orig), buf);
free(copy);
return xstrcpy(buf);
}
int
coprintf (const char *format, ...)
{
va_list
argptr; /* Argument list pointer */
int
fmtsize = 0; /* Size of formatted line */
char
*formatted = NULL, /* Formatted line */
*prefixed = NULL; /* Prefixed formatted line */
if (console_active)
{
formatted = mem_alloc (LINE_MAX + 1);
if (!formatted)
return (0);
va_start (argptr, format); /* Start variable args processing */
vsnprintf (formatted, LINE_MAX, format, argptr);
va_end (argptr); /* End variable args processing */
switch (console_mode)
{
case CONSOLE_DATETIME:
xstrcpy_debug ();
prefixed = xstrcpy (NULL, date_str (), " ", time_str (), ": ",
formatted, NULL);
break;
case CONSOLE_TIME:
xstrcpy_debug ();
prefixed = xstrcpy (NULL, time_str (), ": ", formatted, NULL);
break;
}
if (console_file)
{
file_write (console_file, prefixed? prefixed: formatted);
fflush (console_file);
}
if (console_fct)
(console_fct) (prefixed? prefixed: formatted);
if (console_echo)
{
fprintf (stdout, "%s", prefixed? prefixed: formatted);
fprintf (stdout, "\n");
fflush (stdout);
}
if (prefixed)
{
fmtsize = strlen (prefixed);
mem_free (prefixed);
}
else
fmtsize = strlen (formatted);
mem_free (formatted);
}
return (fmtsize);
}
void UserCity(pid_t pid, char *user, char *city)
{
char *u, *c;
u = xstrcpy(clencode(user));
c = xstrcpy(clencode(city));
SockS("AUSR:3,%d,%s,%s;", pid, u, c);
free(u);
free(c);
}
int log_init(const char *logname, const char *ttyname)
{
FILE *log_f;
char *n, fac[30], *prio;
int fc;
size_t len;
if ( logname == NULL )
return 0;
log_tty = ttyname ? xstrdup( ttyname ) : NULL;
if ( *logname != '$' ) {
log_f = fopen( logname, "at" );
if ( log_f ) {
fclose( log_f );
log_type = LT_LOGFILE;
log_name = xstrdup( logname );
return 1;
}
return 0;
}
if ( ttyname ) {
len = strlen( progname ) + 2 + strlen( ttyname );
n = malloc( len );
if ( !n ) {
fprintf( stderr, "can't malloc() %d bytes of memory\n", len );
abort();
exit(1);
}
xstrcpy( n, progname, len );
xstrcat( n, ".", len );
xstrcat( n, ttyname, len );
} else
n = xstrdup( progname );
prio = strchr( logname + 1, ':' );
if ( prio ) {
prio++;
xstrcpy( fac, logname + 1, 30 );
if (( syslog_priority = parsefacorprio( prio, (SLNCODE *) prioritynames )) < 0 )
syslog_priority = LOG_INFO;
} else
xstrcpy( fac, logname + 1, 30);
if (( fc = parsefacorprio( fac, (SLNCODE *) facilitynames )) < 0 )
return 0;
log_type = LT_SYSLOG;
log_name = NULL;
openlog( n, LOG_PID, fc );
xfree( n );
return 1;
}
void WriteError(const char *format, ...)
{
char *outputstr, *temp;
va_list va_ptr;
int i;
outputstr = calloc(10240, sizeof(char));
va_start(va_ptr, format);
vsnprintf(outputstr, 10240, format, va_ptr);
va_end(va_ptr);
for (i = 0; i < strlen(outputstr); i++)
if (outputstr[i] == '\r' || outputstr[i] == '\n')
outputstr[i] = ' ';
if (*outputstr == '$')
snprintf(outputstr+strlen(outputstr), 10240, ": %s", strerror(errno));
if (strlen(outputstr) > (SS_BUFSIZE - 64)) {
outputstr[SS_BUFSIZE - 65] = ';';
outputstr[SS_BUFSIZE - 64] = '\0';
}
tcrc = StringCRC32(outputstr);
if (tcrc == lcrc) {
lcnt++;
free(outputstr);
return;
} else {
lcrc = tcrc;
if (lcnt) {
lcnt++;
SockS("ALOG:5,%s,%s,%d,?,Last message repeated %d times;", logdebug, progname, mypid, lcnt);
SockS("ALOG:5,%s,%s,%d,?,Last message repeated %d times;", logfile, progname, mypid, lcnt);
SockS("ALOG:5,%s,%s,%d,?,Last message repeated %d times;", errfile, progname, mypid, lcnt);
}
lcnt = 0;
}
if (*outputstr == '$') {
temp = xstrcpy(clencode(outputstr+1));
} else {
temp = xstrcpy(clencode(outputstr));
}
SockS("ALOG:5,%s,%s,%d,?,%s;", logdebug, progname, mypid, temp);
SockS("ALOG:5,%s,%s,%d,?,%s;", logfile, progname, mypid, temp);
SockS("ALOG:5,%s,%s,%d,?,%s;", errfile, progname, mypid, temp);
free(temp);
free(outputstr);
}
int reg_newcon(char *data)
{
char *tty, *uid, *prg, *city;
int retval;
pid_t pid;
strtok(data, ",");
pid = (pid_t)atoi(strtok(NULL, ","));
tty = xstrcpy(strtok(NULL, ","));
uid = xstrcpy(cldecode(strtok(NULL, ",")));
prg = xstrcpy(cldecode(strtok(NULL, ",")));
city = xstrcpy(cldecode(strtok(NULL, ";")));
/*
* Abort if no empty record is found
*/
if ((retval = reg_find((pid_t)0)) == -1) {
Syslog('?', "Maximum clients (%d) reached", MAXCLIENT);
retval = -1;
} else {
memset((char *)®info[retval], 0, sizeof(reg_info));
reginfo[retval].pid = pid;
strncpy((char *)®info[retval].tty, tty, 6);
strncpy((char *)®info[retval].uname, uid, 35);
strncpy((char *)®info[retval].prg, prg, 14);
strncpy((char *)®info[retval].city, city, 35);
strcpy((char *)®info[retval].doing, "-");
reginfo[retval].started = (int)time(NULL);
reginfo[retval].lastcon = (int)time(NULL);
reginfo[retval].altime = 600;
/*
* Everyone says do not disturb, unless the flag
* is cleared by the owner of this process.
*/
reginfo[retval].silent = 1;
stat_inc_clients();
if (strcmp(prg, (char *)"ftncico") == 0)
mailers++;
Syslog('-', "Registered client pgm \"%s\", pid %d, slot %d, mailers %d, TCP/IP %d",
prg, (int)pid, retval, mailers, ipmailers);
}
free(uid);
free(prg);
free(city);
free(tty);
return retval;
}
/* kind = 0 for sent, 1 for toobig */
static void xmsg_unlink_dotfiles(session_t *s, const char *varname)
{
if (session_int_get(s, varname)) {
const int kind = !xstrcasecmp(varname, "unlink_sent");
const int maxfs = session_int_get(s, "max_filesize");
const char *dfsuffix = session_get(s, "dotfile_suffix");
const char *dir = xmsg_dirfix(session_uid_get(s)+XMSG_UID_DIROFFSET);
DIR *d;
struct dirent *de;
struct stat st, std;
char *df, *dfd, *dp, *dpd;
if (!dir || !(d = opendir(dir))) {
xdebug("unable to open specified directory");
return;
}
df = xmalloc(xstrlen(dir) + NAME_MAX + 2);
dfd = xmalloc(xstrlen(dir) + NAME_MAX + 3 + xstrlen(dfsuffix));
xstrcpy(df, dir);
dp = df + xstrlen(df);
*(dp++) = '/';
xstrcpy(dfd, df);
dpd = dfd + xstrlen(dfd);
*(dpd++) = '.';
while ((de = readdir(d))) {
if (de->d_name[0] == '.')
continue;
if (xstrlen(de->d_name) > NAME_MAX) {
xdebug2(DEBUG_ERROR, "Filename longer than NAME_MAX (%s), skipping.", de->d_name);
continue;
}
xstrcpy(dp, de->d_name);
xstrcpy(dpd, de->d_name);
xstrcat(dpd, dfsuffix);
if (!stat(df, &st) && !stat(dfd, &std)
&& ((!maxfs || (st.st_size < maxfs)) == kind)) {
xdebug("removing %s", de->d_name);
unlink(df);
unlink(dfd);
}
}
closedir(d);
xfree(df);
xfree(dfd);
}
}
void get_lastcallerrec_r(int Rec, char *buf)
{
char *temp, action[9], *name, *city;
FILE *fp;
snprintf(buf, SS_BUFSIZE, "201:1,16;");
temp = calloc(PATH_MAX, sizeof(char));
snprintf(temp, PATH_MAX, "%s/etc/lastcall.data", getenv("MBSE_ROOT"));
if ((fp = fopen(temp, "r")) == NULL) {
free(temp);
return;
}
fread(&LCALLhdr, sizeof(LCALLhdr), 1, fp);
fseek(fp, ((Rec -1) * LCALLhdr.recsize) + LCALLhdr.hdrsize, SEEK_SET);
if (fread(&LCALL, LCALLhdr.recsize, 1, fp) == 1) {
LCALL.UserName[15] = '\0';
LCALL.Location[12] = '\0';
strcpy(action, "--------");
if (LCALL.Hidden)
action[0] = 'H';
if (LCALL.Download)
action[1] = 'D';
if (LCALL.Upload)
action[2] = 'U';
if (LCALL.Read)
action[3] = 'R';
if (LCALL.Wrote)
action[4] = 'P';
if (LCALL.Chat)
action[5] = 'C';
if (LCALL.Olr)
action[6] = 'O';
if (LCALL.Door)
action[7] = 'E';
action[8] = '\0';
name = xstrcpy(clencode(LCALL.UserName));
city = xstrcpy(clencode(LCALL.Location));
snprintf(buf, SS_BUFSIZE, "100:9,%s,%s,%d,%s,%s,%d,%d,%s,%s;", name, city,
LCALL.SecLevel, LCALL.Device, LCALL.TimeOn,
(int)LCALL.CallTime, LCALL.Calls, LCALL.Speed, action);
free(name);
free(city);
}
free(temp);
fclose(fp);
return;
}
int mdm_dial(char *phone,char *port)
{
int rc;
char s[MAX_STRING],conn[MAX_STRING];
if((rc=tty_openport(port))) {
write_log("can't open port: %s",tty_errs[rc]);
return MC_BAD;
}
reset();
xstrcpy(s,cfgs(CFG_DIALPREFIX),MAX_STRING);
xstrcat(s,phone,MAX_STRING);
xstrcat(s,cfgs(CFG_DIALSUFFIX),MAX_STRING);
tty_local(1);
sline("Dialing %s",s);vidle();
rc=modem_chat(s,cfgsl(CFG_MODEMCONNECT),cfgsl(CFG_MODEMNODIAL),cfgsl(CFG_MODEMERROR),
cfgsl(CFG_MODEMBUSY),cfgs(CFG_MODEMRINGING),cfgi(CFG_MAXRINGS),
cfgi(CFG_WAITCARRIER),conn,MAX_STRING);
sline("Modem said: %s",conn);
xfree(connstr);connstr=xstrdup(conn);
if(rc!=MC_OK) {
write_log("got %s",conn);
if(rc==MC_FAIL)hangup();
tty_close();
if(rc==MC_RING) {
sline("RING found..");
sleep(2);
execsh("killall -USR1 mgetty vgetty >/dev/null 2>&1");
} else sline("Call failed (%s)",mcs[rc]);
return rc;
}
write_log("*** %s",conn);
tty_local(0);
return rc;
}
void readalias(char *fn)
{
FILE *fp;
char buf[256], *k, *v;
struct aliaslist *tmp = NULL;
faddr *ta = NULL;
if ((fp = fopen(fn,"r")) == NULL) {
WriteError("$cannot open system alias file %s", MBSE_SS(fn));
return;
}
while (fgets(buf, sizeof(buf)-1, fp)) {
k = strtok(buf, " \t:");
v = strtok(NULL, " \t\n\r\0:");
if (k && v)
if ((ta = parsefaddr(v))) {
if (alist) {
tmp->next = (struct aliaslist *) xmalloc(sizeof(struct aliaslist));
tmp = tmp->next;
} else {
alist = (struct aliaslist *) xmalloc(sizeof(struct aliaslist));
tmp = alist;
}
tmp->next = NULL;
tmp->addr = ta;
ta = NULL;
tmp->alias = xstrcpy(k);
}
}
fclose(fp);
}
static int init_child_context (
TCB *tcb,
struct_smtsmtp_message *message,
QID reply_to,
event_t event_number)
{
ASSERT (tcb);
START_BODY
tcb-> thread_type = event_number;
tcb-> message = message;
tcb-> reply_to = reply_to;
tcb-> message_boundary = generate_unique_boundary ();
RAISE_EXC_IF (!tcb-> message_boundary, memory_error_event);
tcb-> plain_text_body_header = xstrcpy (
NULL,
"\r\n--",
tcb-> message_boundary,
"\r\n"
"Content-Type: text/plain; charset=US-ASCII\r\n"
"Content-Transfer-Encoding: 7BIT\r\n"
"Content-description: Body of message\r\n\r\n",
NULL
);
RAISE_EXC_IF (!tcb-> plain_text_body_header, memory_error_event);
END_BODY
return 0;
}
void MakeArc()
{
char *cmd;
if (!getarchiver((char *)"ZIP")) {
WriteError("ZIP Archiver not available");
return;
}
cmd = xstrcpy(archiver.farc);
if (cmd == NULL) {
WriteError("ZIP archive command not available");
return;
}
Nopper();
if (!do_quiet)
printf("Creating allfiles.zip\n");
if (!execute_str(cmd, (char *)"allfiles.zip allfiles.txt allfiles.utf", (char *)NULL, (char *)"/dev/null",
(char *)"/dev/null", (char *)"/dev/null") == 0)
WriteError("Create allfiles.zip failed");
Nopper();
if (!do_quiet)
printf("Creating newfiles.zip\n");
if (!execute_str(cmd, (char *)"newfiles.zip newfiles.txt newfiles.utf", (char *)NULL, (char *)"/dev/null",
(char *)"/dev/null", (char *)"/dev/null") == 0)
WriteError("Create newfiles.zip failed");
free(cmd);
cmd = NULL;
}
/*
* lock:
* Check and lock a file from access by others
* returns TRUE = files was not locked and now is
* FALSE = file was locked and overridden
* ABORT = file was locked, abort command
*
* char *fname; file name to lock
*/
int lock(char *fname)
{
char *locker; /* lock error message */
int status; /* return status */
char msg[NSTRING]; /* message string */
/* attempt to lock the file */
locker = dolock(fname);
if (locker == NULL) /* we win */
return TRUE;
/* file failed...abort */
if (strncmp(locker, "LOCK", 4) == 0) {
lckerror(locker);
return ABORT;
}
/* someone else has it....override? */
xstrcpy(msg, "File in use by ");
strcat(msg, locker);
strcat(msg, ", override?");
status = mlyesno(msg); /* ask them */
if (status == TRUE)
return FALSE;
else
return ABORT;
}
void
sys_assert (const char *File, unsigned Line)
{
#if (defined (__WINDOWS__))
char
line_str [10],
*buffer; /* Formatted error message */
MSG
msg;
Bool
quit;
int
rc; /* MessageBox return code */
snprintf (line_str, sizeof (line_str), "%u", Line);
buffer = xstrcpy (NULL, "Module ", File, ", line ", line_str, NULL);
/* If WM_QUIT is in the queue the message box won't show */
quit = PeekMessage (&msg, NULL, WM_QUIT, WM_QUIT, PM_REMOVE);
rc = MessageBoxA (NULL, buffer, "Assertion failed!",
MB_TASKMODAL | MB_ICONHAND | MB_ABORTRETRYIGNORE);
mem_free (buffer);
if (quit)
PostQuitMessage (msg.wParam);
if (rc != IDABORT)
return;
#else
fflush (stdout);
fprintf (stderr, "\nAssertion failed: %s, line %u\n", File, Line);
fflush (stderr);
#endif
abort ();
}
static int boxflist(flist_t **fl,char *path)
{
DIR *d;
struct dirent *de;
struct stat sb;
char mn[MAX_PATH],*p;
int len;
DEBUG(('S',2,"Add filebox '%s'",path));
if(!(d=opendir(path)))return 0;
else {
while((de=readdir(d))) {
len=strlen(path)+2+strlen(de->d_name);
p=xmalloc(len);
snprintf(p,len,"%s/%s",path,de->d_name);
if(!stat(p,&sb)&&(S_ISREG(sb.st_mode)||S_ISLNK(sb.st_mode))) {
xstrcpy(mn,de->d_name,MAX_PATH);
mapname(mn,cfgs(CFG_MAPOUT),MAX_PATH);
addflist(fl,p,xstrdup(mn),'^',0,NULL,0);
totalf+=sb.st_size;totaln++;
} else xfree(p);
}
closedir(d);
}
return 1;
}
char* irc_get_cmdtype(char *buf, char *raw) {
char *data;
char *type;
int pos = 0;
if(buf == NULL)
return buf;
data = (char*)callocm(MAX_LEN, sizeof(char));
if(data == NULL)
return NULL;
xstrcpy(data, raw, MAX_LEN);
xstrtok(data, " ", &pos);
type = xstrtok(data, " ", &pos);
if(type == NULL) {
freem(data);
return NULL;
}
strcpy(buf, type);
freem(data);
return buf;
}
void SetEmailArea(char *box)
{
char *p;
if (!exitinfo.Email)
return;
/*
* Use a temp variable because this function can be called line SetEmailArea(sMailbox)
*/
p = xstrcpy(box);
snprintf(sMailpath, PATH_MAX, "%s/%s/%s", CFG.bbs_usersdir, exitinfo.Name, p);
snprintf(sMailbox, 21, "%s", p);
free(p);
/*
* Get information from the message base
*/
if (Msg_Open(sMailpath)) {
EmailBase.Lowest = Msg_Lowest();
EmailBase.Highest = Msg_Highest();
EmailBase.Total = Msg_Number();
Msg_Close();
} else
WriteError("Error open JAM %s", sMailpath);
}
int tableSet(PTable t,const pchar Name,const pchar Value)
{
PTablePage p=t->pFirst,q;
int idx0,idx=0,res=0;
p=tableFind(p,&idx,Name);
if(p)
{
q=p;idx0=idx;
while((p=tableFind(p,&idx,Name)))
{
if(t->iFlags&TABLE_FLAG_ALLOCNAME)xfree(p->Values[idx].szName);
if(t->iFlags&TABLE_FLAG_ALLOCVALUE)xfree(p->Values[idx].szValue);
if(idx!=p->iCount-1)memmove(&p->Values[idx],&p->Values[idx+1],sizeof(SAttr)*(p->iCount-idx-1));
p->iCount--;
t->iCount--;
res++;
}
if(res)t->iHoles++;
if(t->iFlags&TABLE_FLAG_ALLOCVALUE)xfree(q->Values[idx].szValue);
if(xstrlen(q->Values[idx0].szValue)>=xstrlen(Value))
xstrcpy(q->Values[idx0].szValue,Value);
else
q->Values[idx0].szValue=xstrdup(t->pPool,Value);
return t->iCount;
}else return tableAdd(t,Name,Value);
}
/*
* xml_escape()
*
* escapes text to be xml-compliant
*
* - text
*
* allocated buffer
*/
char *xml_escape(const char *text) {
const char *p;
char *res, *q;
int len;
if (!text)
return NULL;
for (p = text, len = 0; *p; p++)
len += xml_escape_l(*p);
q = res = xmalloc((len + 1)*sizeof(char));
for (p = text; *p; p++) {
const char *ent = xml_escape_c(*p);
if (ent)
xstrcpy(q, ent);
else
*q = *p;
q += xml_escape_l(*p);
}
return res;
}
/*
* Add the specified entry to the list of files which should be sent
* to the remote system.
* 1. lst file list to add entry to
* 2. local local filename
* 3. remote remote filename
* 4. disposition disposition
* 5. floff offset of entry in flo-file (-1 if this is a flo file)
* 6. flofp FILE * of flo file
* 7. toend append to end of list
*/
void add_list(file_list **lst, char *local, char *Remote, int disposition, off_t floff, FILE *flofp, int toend)
{
file_list **tmpl, *tmp;
Syslog('o', "add_list(\"%s\",\"%s\",%d,%s)", MBSE_SS(local),MBSE_SS(Remote),disposition,toend?"to end":"to beg");
if (toend)
for (tmpl = lst; *tmpl; tmpl =&((*tmpl)->next));
else
tmpl = &tmp;
*tmpl = (file_list*)malloc(sizeof(file_list));
if (toend) {
(*tmpl)->next = NULL;
} else {
(*tmpl)->next = *lst;
*lst = *tmpl;
}
(*tmpl)->remote = xtodos(Remote);
(*tmpl)->local = xstrcpy(local);
(*tmpl)->disposition = disposition;
(*tmpl)->floff = floff;
(*tmpl)->flofp = flofp;
return;
}
unsigned int user_fillmask(struct userNode *user, char *hostmask) {
unsigned int i, x, len, len2, len3;
if((user == NULL) || (blankstr(hostmask)))
return 0;
len = strlen(hostmask);
len2 = strlen(user->nick);
if(len2 >= len)
return 0;
for(i = len2+1, x = 0;x < (len2+MAX_USERLEN);i++, x++) {
if(hostmask[i] == '@')
break;
user->user[x] = hostmask[i];
}
user->user[x] = 0;
len3 = len2+strlen(user->user)+2;
for(x = 0, i++;x < (len3+MAX_MASKLEN);i++, x++) {
if(!hostmask[i])
break;
user->host[x] = hostmask[i];
}
user->host[x] = 0;
xstrcpy(user->hostmask, hostmask, MAX_HOSTMASKLEN);
return 1;
}
char* irc_get_target(char *buf, char *raw) {
char *data;
char *target;
int pos = 0;
if(buf == NULL)
return buf;
data = (char*)callocm(MAX_LEN, sizeof(char));
if(data == NULL)
return NULL;
xstrcpy(data, raw, MAX_LEN);
xstrtok(data, " ", &pos);
xstrtok(data, " ", &pos);
target = xstrtok(data, " ", &pos);
if(target == NULL) {
freem(data);
return NULL;
}
if(*target == ':')
target++;
strcpy(buf, target);
freem(data);
return buf;
}
unsigned int irc_strip_ctrlcodes(char **bufp, const char *text) {
char *buf;
unsigned int text_len;
*bufp = NULL;
if(blankstr(text))
return 0;
text_len = strlen(text)+1;
buf = (char*)callocm(text_len, sizeof(char*));
if(buf == NULL)
return 0;
xstrcpy(buf, text, text_len);
if(blankstr(strrtok(buf, ctrlcodes))) {
freem(buf);
return 0;
}
*bufp = buf;
return strlen(buf);
}
PyObject *ekg_cmd_plugin_get(PyObject * self, PyObject * pyargs)
{
ekg_pluginObj *pyplugin;
plugin_t *p;
char *name = NULL;
int prio = -1;
if (!PyArg_ParseTuple(pyargs, "s:plugin_get", &name))
return NULL;
debug("[python] checking for plugin '%s'\n", name);
p = plugin_find(name);
if (p) {
prio = p->prio;
}
debug("[python] Building object for plugin '%s'\n", name);
pyplugin = PyObject_New(ekg_pluginObj, &ekg_plugin_type);
pyplugin->loaded = prio < 0 ? 0 : 1;
pyplugin->prio = prio < 0 ? 0 : prio;
pyplugin->name = xmalloc(xstrlen(name)+1);
xstrcpy(pyplugin->name, name);
Py_INCREF(pyplugin);
return (PyObject *)pyplugin;
}
void convert (char *directory, char *filename)
{
# define BUFMAX 32000
static char
fullname [1024],
bufin [BUFMAX],
bufout [BUFMAX],
backup [1024],
ch;
int
insize,
outsize,
bufptr;
FILE
*input,
*output;
xstrcpy (fullname, directory, "/", filename, NULL);
if (!file_exists (fullname)) {
printf ("`%s' does not exist", fullname);
exit (1);
}
printf ("Converting %s...\n", fullname);
/* Check if file contains suspicious binary characters */
input = fopen (fullname, "rb");
insize = fread (bufin, 1, 256, input);
for (bufptr = 0; bufptr < insize; bufptr++) {
ch = bufin [bufptr];
if (ch < ' ' && !isspace (ch) && ch != 0x1A) {
printf ("[0x%X at %d] ", bufin [bufptr], bufptr);
printf ("%s is a binary file - skipping\n", fullname);
return;
}
}
fclose (input);
strcpy (backup, fullname);
fixed_extension (backup, fullname, "bak");
file_delete (backup);
file_rename (fullname, backup);
input = fopen (backup, "rb");
output = fopen (fullname, "wb");
if (input == NULL || output == NULL) {
printf ("Error: %s\n", strerror (errno));
exit (1);
}
while ((insize = fread (bufin, 1, BUFMAX, input)) > 0) {
outsize = 0;
for (bufptr = 0; bufptr < insize; bufptr++)
if (bufin [bufptr] != '\r'
&& bufin [bufptr] != 0x1A)
bufout [outsize++] = bufin [bufptr];
ASSERT (fwrite (bufout, 1, outsize, output));
}
fclose (input);
fclose (output);
file_delete (backup);
}
