This repository has been archived on 2024-04-08. You can view files and clone it, but cannot push or open issues or pull requests.
deb-mbse/mbfido/magic.c
2002-05-09 09:29:55 +00:00

443 lines
9.5 KiB
C

/*****************************************************************************
*
* $Id$
* Purpose ...............: .TIC files magic processing.
*
*****************************************************************************
* Copyright (C) 1997-2002
*
* Michiel Broek FIDO: 2:280/2802
* Beekmansbos 10
* 1971 BV IJmuiden
* the Netherlands
*
* This file is part of MBSE BBS.
*
* This BBS is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2, or (at your option) any
* later version.
*
* MBSE BBS is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with MBSE BBS; see the file COPYING. If not, write to the Free
* Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*****************************************************************************/
#include "../lib/libs.h"
#include "../lib/structs.h"
#include "../lib/users.h"
#include "../lib/records.h"
#include "../lib/common.h"
#include "../lib/clcomm.h"
#include "../lib/dbtic.h"
#include "tic.h"
#include "utic.h"
#include "magic.h"
long MagicNr; /* Current magic record number */
int Magics = 0; /* Processed magics */
char *Magic_Macro(int);
char *Magic_Macro(int C)
{
static char buf[PATH_MAX];
buf[0] = '\0';
switch(toupper(C)) {
case 'F':
sprintf(buf, "%s/%s", TIC.BBSpath, TIC.NewName);
break;
case 'P':
sprintf(buf, "%s", TIC.BBSpath);
break;
case 'N':
sprintf(buf, "%s", strtok(strdup(TIC.NewName), "."));
break;
case 'E':
sprintf(buf, "%s", strrchr(TIC.NewName, '.'));
break;
case 'L':
sprintf(buf, "%s", strrchr(TIC.NewName, '.'));
buf[0] = buf[1];
buf[1] = buf[2];
buf[2] = '\0';
break;
case 'D':
sprintf(buf, "%03d", Day_Of_Year());
break;
case 'C':
sprintf(buf, "%03d", Day_Of_Year());
buf[0] = buf[1];
buf[1] = buf[2];
buf[2] = '\0';
break;
case 'A':
sprintf(buf, "%s", TIC.TicIn.Area);
break;
}
Syslog('f', "Mgc Macro(%c): \"%s\"", C, buf);
return buf;
}
int GetMagicRec(int Typ, int First)
{
int Eof = FALSE, DoMagic = TRUE;
int i;
char *temp, *Magic, *p, *q, mask[256];
FILE *FeM;
if (First)
MagicNr = 0;
temp = calloc(PATH_MAX, sizeof(char));
sprintf(temp, "%s/etc/magic.data", getenv("MBSE_ROOT"));
if ((FeM = fopen(temp, "r")) == NULL) {
Syslog('+', "Huh? No magic file? (%s)", temp);
free(temp);
return FALSE;
}
fread(&magichdr, sizeof(magichdr), 1, FeM);
do {
if (fseek(FeM, magichdr.hdrsize + (MagicNr * magichdr.recsize), SEEK_SET) != 0) {
WriteError("$Can't seek record %ld in %s", MagicNr, temp);
free(temp);
fclose(FeM);
return FALSE;
}
MagicNr++;
if (fread(&magic, magichdr.recsize, 1, FeM) == 1) {
if ((magic.Active) && (magic.Attrib == Typ) && (strcasecmp(magic.From, TIC.TicIn.Area) == 0)) {
// p = tl(magic.Mask);
Magic = xstrcpy(magic.Mask);
p = tl(Magic);
q = mask;
*q++ = '^';
while ((*p) && (q < (mask + sizeof(mask) - 4))) {
switch(*p) {
case '\\': *q++ = '\\'; *q++ = '\\'; break;
case '?': *q++ = '.'; break;
case '.': *q++ = '\\'; *q++ = '.'; break;
case '+': *q++ = '\\'; *q++ = '+'; break;
case '*': *q++ = '.'; *q++ = '*'; break;
case '@': sprintf(q, "[A-Za-z]"); while (*q) q++; break;
case '#': sprintf(q, "[0-9]"); while (*q) q++; break;
default: *q++ = *p; break;
}
p++;
}
*q++ = '$';
*q = '\0';
Syslog('f', "Magic mask \"%s\" -> \"%s\"", MBSE_SS(Magic), MBSE_SS(mask));
if ((re_comp(mask)) == NULL) {
if (re_exec(TIC.NewName))
Syslog('f', "Should matched using regexp");
else
Syslog('f', "No match using regexp");
} else {
Syslog('f', "re_comp() failed");
}
free(Magic);
/*
* Comparing of the filename must be done in
* two parts, before and after the dot.
*/
if (strlen(magic.Mask) == strlen(TIC.NewName)) {
for (i = 0; i < strlen(magic.Mask); i++) {
switch (magic.Mask[i]) {
case '?': break;
case '@': if (!isalpha(TIC.NewName[i]))
DoMagic = FALSE;
break;
case '#': if (!isdigit(TIC.NewName[i]))
DoMagic = FALSE;
break;
default: if (toupper(TIC.NewName[i]) != toupper(magic.Mask[i]))
DoMagic = FALSE;
}
}
} else {
DoMagic = FALSE;
}
Syslog('f', "Old test, found %s", DoMagic ? "True":"False");
if (DoMagic) {
fclose(FeM);
free(temp);
return TRUE;
}
}
} else {
Eof = TRUE;
}
} while (!Eof);
free(temp);
fclose(FeM);
return FALSE;
}
void MagicResult(char *format, ...)
{
char *outputstr;
va_list va_ptr;
outputstr = calloc(1024, sizeof(char));
va_start(va_ptr, format);
vsprintf(outputstr, format, va_ptr);
va_end(va_ptr);
Syslog('+', "Magic: %s", outputstr);
free(outputstr);
Magics++;
}
void Magic_CheckCompile(void);
void Magic_CheckCompile(void)
{
if (magic.Compile) {
CompileNL = TRUE;
Syslog('+', "Magic: Trigger Compile Nodelists");
}
}
int Magic_MoveFile(void)
{
if (GetMagicRec(MG_MOVE, TRUE)) {
strcpy(TIC.TicIn.Area, magic.ToArea);
MagicResult((char *)"Move %s to Area %s", TIC.RealName, TIC.TicIn.Area);
return TRUE;
} else
return FALSE;
}
void Magic_ExecCommand(void)
{
int i, j, k, Err, First = TRUE;
char Line[256];
char Temp[PATH_MAX];
char *cmd, *opts;
while (GetMagicRec(MG_EXEC, First)) {
First = FALSE;
j = 0;
memset(&Line, 0, sizeof(Line));
for (i = 0; i < strlen(magic.Cmd); i++) {
if (magic.Cmd[i] != '%') {
Line[j] = magic.Cmd[i];
j++;
} else {
i++;
if (magic.Cmd[i] == '%') {
Line[j] = '%';
j++;
} else {
Temp[0] = '\0';
sprintf(Temp, "%s", Magic_Macro(magic.Cmd[i]));
for (k = 0; k < strlen(Temp); k++) {
Line[j] = Temp[k];
j++;
}
}
}
}
cmd = xstrcpy(getenv("MBSE_ROOT"));
cmd = xstrcat(cmd, (char *)"/bin/");
cmd = xstrcat(cmd, strtok(Line, " "));
opts = strtok(NULL, "\0");
MagicResult((char *)"Exec: \"%s %s\"", cmd, opts);
if ((Err = execute(cmd, opts, NULL, (char *)"/dev/null", (char *)"/dev/null", (char *)"/dev/null")) == 0) {
Magics++;
} else
Syslog('!', "Mgc Exec: (%s %s) returns %d", cmd, opts, Err);
Magic_CheckCompile();
}
}
void Magic_CopyFile(void)
{
int First = TRUE;
char *From, *To;
From = calloc(PATH_MAX, sizeof(char));
To = calloc(PATH_MAX, sizeof(char));
while (GetMagicRec(MG_COPY, First)) {
First = FALSE;
sprintf(From, "%s/%s", TIC.BBSpath, TIC.NewName);
sprintf(To, "%s/%s", magic.Path, TIC.NewName);
if (file_cp(From, To) == 0) {
MagicResult((char *)"%s copied to %s", From, To);
Magic_CheckCompile();
} else
WriteError("Magic: copy: %s to %s failed");
}
free(From);
free(To);
}
void Magic_UnpackFile(void)
{
int rc, First = TRUE;
char *buf = NULL, *unarc = NULL, *cmd = NULL;
char Fn[PATH_MAX];
while (GetMagicRec(MG_UNPACK, First)) {
First = FALSE;
buf = calloc(PATH_MAX, sizeof(char));
getcwd(buf, 128);
if (chdir(magic.Path) == 0) {
sprintf(Fn, "%s/%s", TIC.BBSpath, TIC.NewName);
if ((unarc = unpacker(Fn)) != NULL) {
if (getarchiver(unarc)) {
cmd = xstrcpy(archiver.funarc);
if (strlen(cmd)) {
rc = execute(cmd, Fn, (char *)NULL, (char *)"/dev/null", (char *)"/dev/null", (char *)"/dev/null");
sync();
if (rc)
WriteError("$Magic: unpack in %s, error %d", magic.Path, rc);
else
MagicResult((char *)"unpacked in %s", magic.Path);
}
free(cmd);
}
}
chdir(buf);
Magic_CheckCompile();
} else
WriteError("$Magic: unpack: can't chdir \"%s\"", magic.Path);
free(buf);
}
}
void Magic_Keepnum(void)
{
if (GetMagicRec(MG_KEEPNUM, TRUE)) {
TIC.KeepNum = magic.KeepNum;
MagicResult((char *)"Keep %d files", TIC.KeepNum);
}
}
void Magic_UpDateAlias(void)
{
if (GetMagicRec(MG_UPDALIAS, TRUE)) {
UpDateAlias(TIC.TicIn.Area);
MagicResult((char *)"Update Alias");
}
}
void Magic_AdoptFile(void)
{
int First = TRUE;
char *temp;
FILE *Tf;
temp = calloc(PATH_MAX, sizeof(char));
while (GetMagicRec(MG_ADOPT, First)) {
First = FALSE;
if (SearchTic(magic.ToArea)) {
MagicResult((char *)"Adoptfile in %s", magic.ToArea);
sprintf(temp, "%s/%s", TIC.Inbound, MakeTicName());
if ((Tf = fopen(temp, "a+")) == NULL)
WriteError("$Can't create %s", temp);
else {
fprintf(Tf, "Hatch\r\n");
fprintf(Tf, "NoMove\r\n");
fprintf(Tf, "Created MBSE BBS v%s, %s\r\n", VERSION, SHORTRIGHT);
fprintf(Tf, "Area %s\r\n", magic.ToArea);
fprintf(Tf, "Origin %s\r\n", aka2str(tic.Aka));
fprintf(Tf, "From %s\r\n", aka2str(tic.Aka));
if (strlen(TIC.TicIn.Replace))
fprintf(Tf, "Replaces %s\r\n", TIC.TicIn.Replace);
if (strlen(TIC.TicIn.Magic))
fprintf(Tf, "Magic %s\r\n", TIC.TicIn.Magic);
fprintf(Tf, "File %s\r\n", TIC.NewName);
fprintf(Tf, "Pth %s\r\n", TIC.BBSpath);
fprintf(Tf, "Desc %s\r\n", TIC.TicIn.Desc);
fprintf(Tf, "Crc %s\r\n", TIC.TicIn.Crc);
fprintf(Tf, "Pw %s\r\n", CFG.hatchpasswd);
fclose(Tf);
}
SearchTic(TIC.TicIn.Area);
} else
WriteError("Mgc Adopt: Area \"%s\" not found");
}
free(temp);
}
int Magic_DeleteFile(void)
{
int Result;
if ((Result = GetMagicRec(MG_DELETE, TRUE)))
MagicResult((char *)"Delete file");
return Result;
}