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/mbsebbs/filesub.c

1136 lines
27 KiB
C
Raw Normal View History

2001-08-17 05:46:24 +00:00
/*****************************************************************************
*
* $Id$
2001-08-17 05:46:24 +00:00
* Purpose ...............: All the file sub functions.
*
*****************************************************************************
2007-02-03 12:41:26 +00:00
* Copyright (C) 1997-2007
2001-08-17 05:46:24 +00:00
*
* 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
2003-08-15 20:05:34 +00:00
* Software Foundation, 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
2001-08-17 05:46:24 +00:00
*****************************************************************************/
2002-06-30 12:48:44 +00:00
#include "../config.h"
2004-02-21 17:22:00 +00:00
#include "../lib/mbselib.h"
2001-08-17 05:46:24 +00:00
#include "../lib/mbse.h"
2002-01-07 19:16:03 +00:00
#include "../lib/users.h"
2004-05-06 21:33:13 +00:00
#include "../lib/mbsedb.h"
2001-08-17 05:46:24 +00:00
#include "filesub.h"
#include "funcs.h"
#include "language.h"
#include "input.h"
2001-08-17 05:46:24 +00:00
#include "misc.h"
#include "timeout.h"
#include "exitinfo.h"
#include "change.h"
#include "term.h"
2004-11-03 20:48:45 +00:00
#include "ttyio.h"
2001-08-17 05:46:24 +00:00
2004-04-11 20:05:29 +00:00
extern pid_t mypid;
2005-10-11 20:49:41 +00:00
int arecno = 1; /* Area record number */
2004-04-11 20:05:29 +00:00
int Hcolor = 9; /* Color of area line in xxxScan() functions */
2005-10-07 20:42:35 +00:00
extern int rows;
2001-08-17 05:46:24 +00:00
/*
* Variables for file tagging
*/
int Tagnr;
_Tag Tagbuf[100];
/*
* Reset the tag ringbuffer.
*/
void InitTag()
{
2004-11-03 20:48:45 +00:00
int i;
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
Tagnr = 0;
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
for (i = 0; i < 100; i++) {
memset(&Tagbuf[i], 0, sizeof(_Tag));
}
2001-08-17 05:46:24 +00:00
}
/*
* Add a file in the tag ringbuffer.
*/
void SetTag(_Tag tag)
{
2004-11-03 20:48:45 +00:00
if (Tagnr < 99)
Tagnr++;
else
Tagnr = 1;
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
Tagbuf[Tagnr] = tag;
2001-08-17 05:46:24 +00:00
}
/*
* Get string, no newline afterwards.
*/
void GetstrD(char *sStr, int iMaxlen)
{
2004-11-03 20:48:45 +00:00
unsigned char ch = 0;
int iPos = 0;
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
strcpy(sStr, "");
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
alarm_on();
while (ch != 13) {
ch = Readkey();
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
if (((ch == 8) || (ch == KEY_DEL) || (ch == 127)) && (iPos > 0)) {
BackErase();
sStr[--iPos]='\0';
2001-08-17 05:46:24 +00:00
}
2004-11-03 20:48:45 +00:00
if (ch > 31 && ch < 127) {
if (iPos <= iMaxlen) {
iPos++;
2005-08-29 13:42:56 +00:00
snprintf(sStr + strlen(sStr), 5, "%c", ch);
2004-11-03 20:48:45 +00:00
PUTCHAR(ch);
} else
PUTCHAR(7);
}
}
2001-08-17 05:46:24 +00:00
}
/*
* Open the fareas.data file for read or R/W and read the headerrecord.
* The filepointer is at the start of the first record.
*/
FILE *OpenFareas(int Write)
{
2004-11-03 20:48:45 +00:00
FILE *pAreas;
char *FileArea;
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
FileArea = calloc(PATH_MAX, sizeof(char));
2005-08-29 11:46:06 +00:00
snprintf(FileArea, PATH_MAX, "%s/etc/fareas.data", getenv("MBSE_ROOT"));
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
if (Write)
pAreas = fopen(FileArea, "r+");
else
pAreas = fopen(FileArea, "r");
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
if (pAreas == NULL) {
WriteError("$Can't open FileBase %s", FileArea);
/* FATAL: Unable to open areas database */
pout(LIGHTRED, BLACK, (char *) Language(243));
Enter(2);
sleep(2);
} else
fread(&areahdr, sizeof(areahdr), 1, pAreas);
free(FileArea);
return pAreas;
2001-08-17 05:46:24 +00:00
}
/*
* Pageheader for filelistings
*/
void Header()
{
2004-11-03 20:48:45 +00:00
char temp[81];
pout(RED, LIGHTGRAY, (char *)" Area ");
2001-08-17 05:46:24 +00:00
2005-08-29 11:46:06 +00:00
snprintf(temp, 81, "%-5d ", iAreaNumber);
2004-11-03 20:48:45 +00:00
pout(RED, LIGHTGRAY, temp);
2001-08-17 05:46:24 +00:00
2005-08-29 11:46:06 +00:00
snprintf(temp, 81, "%-65s", sAreaDesc);
2004-11-03 20:48:45 +00:00
pout(BLUE, LIGHTGRAY, temp);
Enter(1);
2001-08-17 05:46:24 +00:00
2005-08-29 11:46:06 +00:00
colour(WHITE, BLACK);
2004-11-03 20:48:45 +00:00
fLine(79);
2001-08-17 05:46:24 +00:00
}
/*
* Searchheader for areas during xxxxScan().
*/
void Sheader()
{
2004-11-03 20:48:45 +00:00
char temp[81];
PUTCHAR('\r');
2005-10-11 20:49:41 +00:00
snprintf(temp, 81, " %-4d", arecno);
2004-11-03 20:48:45 +00:00
pout(Hcolor, BLACK, temp);
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
pout(LIGHTBLUE, BLACK, (char *)" ... ");
2001-08-17 05:46:24 +00:00
2005-08-29 11:46:06 +00:00
snprintf(temp, 81, "%-44s", area.Name);
2004-11-03 20:48:45 +00:00
pout(Hcolor, BLACK, temp);
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
if (Hcolor < WHITE)
Hcolor++;
else
Hcolor = LIGHTBLUE;
2001-08-17 05:46:24 +00:00
}
/*
* Blank current line without newline.
*/
void Blanker(int count)
{
2004-11-03 20:48:45 +00:00
int i;
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
for (i = 0; i < count; i++)
PUTCHAR('\b');
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
for (i = 0; i < count; i++)
PUTCHAR(' ');
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
PUTCHAR('\r');
2001-08-17 05:46:24 +00:00
}
/*
* Mark one or more files for download by putting them into the "taglist"
* in the users homedirectory. Check against dupe tags.
*/
void Mark()
{
2004-11-03 20:48:45 +00:00
char *temp;
FILE *fp;
int i, Found, Count, Size;
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
temp = calloc(81, sizeof(char));
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
/*
* First count the already tagged files.
*/
Count = Size = 0;
if ((fp = fopen("taglist", "r")) != NULL) {
while (fread(&Tag, sizeof(Tag), 1, fp) == 1) {
if (Tag.Active) {
Count++;
Size += (Tag.Size / 1024);
}
2001-08-17 05:46:24 +00:00
}
2004-11-03 20:48:45 +00:00
fclose(fp);
}
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
/* Marked: */
2005-08-29 11:46:06 +00:00
snprintf(temp, 81, "%s%d, %dK; ", (char *) Language(360), Count, Size);
2004-11-03 20:48:45 +00:00
pout(CFG.HiliteF, CFG.HiliteB, temp);
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
/* Mark file number of press <Enter> to stop */
PUTSTR((char *) Language(7));
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
colour(CFG.InputColourF, CFG.InputColourB);
GetstrD(temp, 10);
Blanker(strlen(Language(7)) + strlen(temp));
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
if (strlen(temp) == 0) {
free(temp);
return;
}
i = atoi(temp);
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
if ((i > 0) && (i < 100)) {
if ((Tagbuf[i].Area) && (strlen(Tagbuf[i].LFile))) {
if (Access(exitinfo.Security, area.DLSec)) {
if ((fp = fopen("taglist", "a+")) != NULL) {
fseek(fp, 0, SEEK_SET);
Found = FALSE;
while (fread(&Tag, sizeof(Tag), 1, fp) == 1)
if ((Tag.Area == Tagbuf[i].Area) && (strcmp(Tag.LFile, Tagbuf[i].LFile) == 0)) {
Found = TRUE;
Syslog('b', "Tagbuf[i].File already tagged");
2001-08-17 05:46:24 +00:00
}
2004-11-03 20:48:45 +00:00
if (!Found) {
memset(&Tag, 0, sizeof(Tag));
Tag = Tagbuf[i];
Tag.Active = TRUE;
fwrite(&Tag, sizeof(Tag), 1, fp);
Syslog('+', "Tagged file %s from area %d", Tag.LFile, Tag.Area);
}
fclose(fp);
2001-08-17 05:46:24 +00:00
}
2004-11-03 20:48:45 +00:00
} else {
/* You do not have enough access to download from this area. */
pout(LIGHTRED, BLACK, (char *) Language(244));
sleep(3);
Blanker(strlen(Language(244)));
}
2001-08-17 05:46:24 +00:00
}
2004-11-03 20:48:45 +00:00
}
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
free(temp);
2001-08-17 05:46:24 +00:00
}
/*
* More prompt, returns 1 if user decides not to look any further.
*/
int iLC(int Lines)
{
2004-11-03 20:48:45 +00:00
int x, z;
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
x = strlen(Language(131));
iLineCount += Lines;
2001-08-17 05:46:24 +00:00
2005-10-07 20:42:35 +00:00
if ((iLineCount >= rows) && (iLineCount < 1000)) {
2004-11-03 20:48:45 +00:00
iLineCount = 0;
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
while (TRUE) {
/* More (Y/n/=) M=Mark */
pout(CFG.MoreF, CFG.MoreB, (char *) Language(131));
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
alarm_on();
z = toupper(Readkey());
Blanker(x);
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
if (z == Keystroke(131, 1)) {
Enter(1);
return 1;
}
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
if (z == Keystroke(131, 2)) {
iLineCount = 9000;
return 0;
}
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
if ((z == Keystroke(131, 0)) || (z == '\r') || (z == '\n')) {
return 0;
}
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
if (z == Keystroke(131, 3)) {
Mark();
}
2001-08-17 05:46:24 +00:00
}
2004-11-03 20:48:45 +00:00
}
return 0;
2001-08-17 05:46:24 +00:00
}
/*
* Show one file, return 1 if user wants to stop, 0 to show next file.
*/
int ShowOneFile()
{
2004-11-03 20:48:45 +00:00
int y, z, fg, bg;
char temp[81];
2001-08-17 05:46:24 +00:00
2004-03-06 21:48:41 +00:00
if (!fdb.Deleted) {
2001-08-17 05:46:24 +00:00
2005-08-29 11:46:06 +00:00
snprintf(temp, 81, " %02d ", Tagnr);
2004-11-03 20:48:45 +00:00
pout(LIGHTGRAY, BLACK, temp);
2001-08-17 05:46:24 +00:00
2005-08-29 11:46:06 +00:00
snprintf(temp, 81, "%-12s", fdb.Name);
2004-11-03 20:48:45 +00:00
pout(CFG.FilenameF, CFG.FilenameB, temp);
2001-08-17 05:46:24 +00:00
2005-10-11 20:49:41 +00:00
snprintf(temp, 81, "%10u ", (int)(fdb.Size));
2004-11-03 20:48:45 +00:00
pout(CFG.FilesizeF, CFG.FilesizeB, temp);
2001-08-17 05:46:24 +00:00
2005-08-29 11:46:06 +00:00
snprintf(temp, 81, "%-10s ", StrDateDMY(fdb.UploadDate));
2004-11-03 20:48:45 +00:00
pout(CFG.FiledateF, CFG.FiledateB, temp);
2001-08-17 05:46:24 +00:00
2005-10-11 20:49:41 +00:00
snprintf(temp, 81, "[%4d] ", fdb.TimesDL);
2004-11-03 20:48:45 +00:00
pout(LIGHTRED, BLACK, temp);
2001-08-17 05:46:24 +00:00
2004-03-06 21:48:41 +00:00
if ((strcmp(fdb.Uploader, "")) == 0)
strcpy(fdb.Uploader, "SysOp");
2001-08-17 05:46:24 +00:00
2005-08-29 11:46:06 +00:00
snprintf(temp, 81, "%s%s", (char *) Language(238), fdb.Uploader);
2004-11-03 20:48:45 +00:00
pout(CFG.HiliteF, CFG.HiliteB, temp);
Enter(1);
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
if (iLC(1) == 1)
return 1;
2001-08-17 05:46:24 +00:00
2004-03-06 21:48:41 +00:00
for (z = 0; z < 25; z++) {
if ((y = strlen(fdb.Desc[z])) > 1) {
if ((fdb.Desc[z][0] == '@') && (fdb.Desc[z][1] == 'X')) {
2003-08-03 12:17:35 +00:00
/*
* Color formatted description lines.
*/
2004-03-06 21:48:41 +00:00
if (fdb.Desc[z][3] > '9')
fg = (int)fdb.Desc[z][3] - 55;
2003-08-03 12:17:35 +00:00
else
2004-03-06 21:48:41 +00:00
fg = (int)fdb.Desc[z][3] - 48;
bg = (int)fdb.Desc[z][2] - 48;
2005-08-29 11:46:06 +00:00
snprintf(temp, 81, " %s",fdb.Desc[z]+4);
2004-11-03 20:48:45 +00:00
pout(fg, bg, temp);
2003-08-03 12:17:35 +00:00
} else {
2005-08-29 11:46:06 +00:00
snprintf(temp, 81, " %s",fdb.Desc[z]);
2004-11-03 20:48:45 +00:00
pout(CFG.FiledescF, CFG.FiledescB, temp);
2001-08-17 05:46:24 +00:00
}
2004-11-03 20:48:45 +00:00
Enter(1);
2003-08-03 12:17:35 +00:00
if (iLC(1) == 1)
return 1;
}
2001-08-17 05:46:24 +00:00
}
2003-08-03 12:17:35 +00:00
}
return 0;
2001-08-17 05:46:24 +00:00
}
2005-10-11 20:49:41 +00:00
int CheckBytesAvailable(int CostSize)
2001-08-17 05:46:24 +00:00
{
2004-11-03 20:48:45 +00:00
char temp[81];
if (LIMIT.DownK) {
if ((exitinfo.DownloadKToday <= 0) || ((CostSize / 1024) > exitinfo.DownloadKToday)) {
/* You do not have enough bytes to download \" */
pout(LIGHTRED, BLACK, (char *) Language(252));
Enter(1);
Syslog('+', "Not enough bytes to download %ld", CostSize);
2001-08-17 05:46:24 +00:00
/* You must upload before you can download. */
pout(LIGHTRED, BLACK, (char *) Language(253));
Enter(2);
2001-08-17 05:46:24 +00:00
/* Kilobytes currently available: */
2005-10-11 20:49:41 +00:00
snprintf(temp, 81, "%s%u Kbytes.", (char *) Language(254), exitinfo.DownloadKToday);
2004-11-03 20:48:45 +00:00
pout(YELLOW, BLACK, temp);
Enter(2);
2001-08-17 05:46:24 +00:00
Pause();
return FALSE;
2001-08-17 05:46:24 +00:00
}
}
2001-08-17 05:46:24 +00:00
return TRUE;
2001-08-17 05:46:24 +00:00
}
/*
* Change back to users homedir.
*/
void Home()
{
2003-08-03 12:17:35 +00:00
char *temp;
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
temp = calloc(PATH_MAX, sizeof(char));
2005-08-29 11:46:06 +00:00
snprintf(temp, PATH_MAX, "%s/%s", CFG.bbs_usersdir, exitinfo.Name);
2003-08-03 12:17:35 +00:00
chdir(temp);
free(temp);
2001-08-17 05:46:24 +00:00
}
/*
* Scan a .COM or .EXE file in users upload directory.
*/
int ScanDirect(char *fn)
{
2004-04-11 20:05:29 +00:00
FILE *fp, *lp;
2003-08-03 12:17:35 +00:00
int err, Found = FALSE;
2004-11-03 20:48:45 +00:00
char *temp, *temp1, *stdlog, *errlog, buf[256], msg[81];
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
temp = calloc(PATH_MAX, sizeof(char));
temp1 = calloc(PATH_MAX, sizeof(char));
2004-04-11 20:05:29 +00:00
stdlog = calloc(PATH_MAX, sizeof(char));
errlog = calloc(PATH_MAX, sizeof(char));
2005-08-29 11:46:06 +00:00
snprintf(temp, PATH_MAX, "%s/%s/upl/%s", CFG.bbs_usersdir, exitinfo.Name, fn);
snprintf(temp1, PATH_MAX, "%s/etc/virscan.data", getenv("MBSE_ROOT"));
snprintf(stdlog, PATH_MAX, "%s/tmp/stdlog%d", getenv("MBSE_ROOT"), mypid);
snprintf(errlog, PATH_MAX, "%s/tmp/errlog%d", getenv("MBSE_ROOT"), mypid);
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
if ((fp = fopen(temp1, "r")) != NULL) {
fread(&virscanhdr, sizeof(virscanhdr), 1, fp);
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
while (fread(&virscan, virscanhdr.recsize, 1, fp) == 1) {
2001-08-17 05:46:24 +00:00
2007-02-03 13:12:20 +00:00
if (virscan.available && (file_exist(virscan.scanner, X_OK) == 0)) {
2003-08-03 12:17:35 +00:00
/* Scanning */ /* with */
2005-08-29 11:46:06 +00:00
snprintf(msg, 81, "%s %s %s %s ", (char *) Language(132), fn, (char *) Language(133), virscan.comment);
2004-11-03 20:48:45 +00:00
pout(CFG.TextColourF, CFG.TextColourB, msg);
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
Altime(3600);
2004-04-11 20:05:29 +00:00
err = execute_str(virscan.scanner, virscan.options, temp, (char *)"/dev/null", stdlog, errlog);
if (file_size(stdlog)) {
if ((lp = fopen(stdlog, "r"))) {
while (fgets(buf, sizeof(buf) -1, lp)) {
Striplf(buf);
Syslog('+', "stdout: \"%s\"", printable(buf, 0));
}
fclose(lp);
}
}
if (file_size(errlog)) {
if ((lp = fopen(errlog, "r"))) {
while (fgets(buf, sizeof(buf) -1, lp)) {
Striplf(buf);
Syslog('+', "stderr: \"%s\"", printable(buf, 0));
}
fclose(lp);
}
}
unlink(stdlog);
unlink(errlog);
if (err != virscan.error) {
2003-08-03 12:17:35 +00:00
WriteError("VIRUS ALERT: Result %d (%s)", err, virscan.comment);
/* Possible VIRUS found! */
2005-08-29 11:46:06 +00:00
snprintf(msg, 81, "%s", (char *) Language(199));
2004-11-03 20:48:45 +00:00
pout(CFG.HiliteF, CFG.HiliteB, msg);
2003-08-03 12:17:35 +00:00
Found = TRUE;
} else {
/* Ok */
2005-08-29 11:46:06 +00:00
snprintf(msg, 81, "%s", (char *) Language(200));
2004-11-03 20:48:45 +00:00
PUTSTR(msg);
2001-08-17 05:46:24 +00:00
}
2004-11-03 20:48:45 +00:00
Enter(1);
2003-08-03 12:17:35 +00:00
Altime(0);
2004-04-11 20:05:29 +00:00
Nopper();
2003-08-03 12:17:35 +00:00
}
2001-08-17 05:46:24 +00:00
}
2003-08-03 12:17:35 +00:00
fclose(fp);
}
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
free(temp);
free(temp1);
2004-04-11 20:05:29 +00:00
free(stdlog);
free(errlog);
2003-08-03 12:17:35 +00:00
return Found;
2001-08-17 05:46:24 +00:00
}
/*
* Scan archive using users ./tmp directory.
* Return codes:
* 0 - All seems well
* 1 - Error unpacking archive
* 2 - Possible virus found
* 3 - Not a known archive format.
*/
int ScanArchive(char *fn, char *ftype)
{
2004-04-11 20:05:29 +00:00
FILE *fp, *lp;
int err = 0, Found = FALSE;
2004-11-03 20:48:45 +00:00
char *temp, *stdlog, *errlog, buf[256], msg[81];
char *cwd = NULL;
/*
* First search for the right archiver program
*/
temp = calloc(PATH_MAX, sizeof(char));
2004-04-11 20:05:29 +00:00
stdlog = calloc(PATH_MAX, sizeof(char));
errlog = calloc(PATH_MAX, sizeof(char));
2005-08-29 11:46:06 +00:00
snprintf(temp, PATH_MAX, "%s/etc/archiver.data", getenv("MBSE_ROOT"));
snprintf(stdlog, PATH_MAX, "%s/tmp/stdlog%d", getenv("MBSE_ROOT"), mypid);
snprintf(errlog, PATH_MAX, "%s/tmp/errlog%d", getenv("MBSE_ROOT"), mypid);
2004-04-11 20:05:29 +00:00
if ((fp = fopen(temp, "r")) == NULL) {
free(temp);
return 3;
}
2001-08-17 05:46:24 +00:00
fread(&archiverhdr, sizeof(archiverhdr), 1, fp);
2001-08-17 05:46:24 +00:00
while (fread(&archiver, archiverhdr.recsize, 1, fp) == 1) {
if ((strcmp(ftype, archiver.name) == 0) && (archiver.available)) {
break;
2001-08-17 05:46:24 +00:00
}
}
fclose(fp);
if ((strcmp(ftype, archiver.name)) || (!archiver.available)) {
free(temp);
return 3;
}
2001-08-17 05:46:24 +00:00
cwd = getcwd(cwd, 80);
2005-08-29 11:46:06 +00:00
snprintf(temp, PATH_MAX, "%s/%s/tmp", CFG.bbs_usersdir, exitinfo.Name);
if (chdir(temp)) {
WriteError("$Can't chdir(%s)", temp);
free(temp);
return 1;
}
2001-08-17 05:46:24 +00:00
/* Unpacking archive */
2005-08-29 11:46:06 +00:00
snprintf(msg, 81, "%s %s ", (char *) Language(201), fn);
2004-11-03 20:48:45 +00:00
pout(CFG.TextColourF, CFG.TextColourB, msg);
2001-08-17 05:46:24 +00:00
if (!strlen(archiver.funarc)) {
WriteError("No unarc command available");
} else {
2005-08-29 11:46:06 +00:00
snprintf(temp, PATH_MAX, "%s/%s/upl/%s", CFG.bbs_usersdir, exitinfo.Name, fn);
2004-03-02 20:47:23 +00:00
if (execute_str(archiver.funarc, temp, (char *)NULL, (char *)"/dev/null", (char *)"/dev/null", (char *)"/dev/null")) {
WriteError("$Failed %s %s", archiver.funarc, temp);
2004-03-02 20:47:23 +00:00
execute_pth((char *)"rm", (char *)"-r -f ./*", (char *)"/dev/null", (char *)"/dev/null", (char *)"/dev/null");
chdir(cwd);
free(cwd);
/* ERROR */
2004-11-03 20:48:45 +00:00
pout(CFG.HiliteF, CFG.HiliteB, (char *) Language(217));
Enter(1);
return 1;
2001-08-17 05:46:24 +00:00
}
}
2001-08-17 05:46:24 +00:00
/* Ok */
2004-11-03 20:48:45 +00:00
PUTSTR((char *) Language(200));
Enter(1);
2001-08-17 05:46:24 +00:00
2005-08-29 11:46:06 +00:00
snprintf(temp, PATH_MAX, "%s/etc/virscan.data", getenv("MBSE_ROOT"));
2001-08-17 05:46:24 +00:00
if ((fp = fopen(temp, "r")) != NULL) {
fread(&virscanhdr, sizeof(virscanhdr), 1, fp);
while (fread(&virscan, virscanhdr.recsize, 1, fp) == 1) {
2001-08-17 05:46:24 +00:00
2007-02-03 13:12:20 +00:00
if (virscan.available && (file_exist(virscan.scanner, X_OK) == 0)) {
/* Scanning */ /* with */
2005-08-29 11:46:06 +00:00
snprintf(msg, 81, "%s %s %s %s ", (char *) Language(132), fn, (char *) Language(133), virscan.comment);
2004-11-03 20:48:45 +00:00
pout(CFG.TextColourF, CFG.TextColourB, msg);
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
Altime(3600);
2005-11-25 19:39:16 +00:00
err = execute_str(virscan.scanner, virscan.options, (char *)NULL, (char *)"/dev/null", stdlog, errlog);
2004-04-11 20:05:29 +00:00
if (file_size(stdlog)) {
if ((lp = fopen(stdlog, "r"))) {
while (fgets(buf, sizeof(buf) -1, lp)) {
Striplf(buf);
Syslog('+', "stdout: \"%s\"", printable(buf, 0));
}
fclose(lp);
}
}
if (file_size(errlog)) {
if ((lp = fopen(errlog, "r"))) {
while (fgets(buf, sizeof(buf) -1, lp)) {
Striplf(buf);
Syslog('+', "stderr: \"%s\"", printable(buf, 0));
}
fclose(lp);
}
}
unlink(stdlog);
unlink(errlog);
if (err != virscan.error) {
WriteError("VIRUS ALERT: Result %d (%s)", err, virscan.comment);
/* Possible VIRUS found! */
2004-11-03 20:48:45 +00:00
pout(CFG.HiliteF, CFG.HiliteB, (char *) Language(199));
Found = TRUE;
} else {
/* Ok */
2004-11-03 20:48:45 +00:00
PUTSTR((char *) Language(200));
2001-08-17 05:46:24 +00:00
}
2004-11-03 20:48:45 +00:00
Enter(1);
2003-08-03 12:17:35 +00:00
Altime(0);
Nopper();
}
2001-08-17 05:46:24 +00:00
}
fclose(fp);
}
2001-08-17 05:46:24 +00:00
2004-03-02 20:47:23 +00:00
execute_pth((char *)"rm", (char *)"-r -f ./*", (char *)"/dev/null", (char *)"/dev/null", (char *)"/dev/null");
chdir(cwd);
free(cwd);
free(temp);
2004-04-11 20:05:29 +00:00
free(stdlog);
free(errlog);
if (Found)
return 2;
else
return 0;
2001-08-17 05:46:24 +00:00
}
/*
* Try to find out the type of uploaded file.
*/
char *GetFileType(char *fn)
{
unsigned char buf[8], dbuf[80];
FILE *fp;
int i;
if ((fp = fopen(fn, "r")) == NULL) {
WriteError("$Can't open file %s", fn);
return NULL;
}
if (fread(buf, 1, sizeof(buf), fp) != sizeof(buf)) {
WriteError("$Can't read head of file %s", fn);
return NULL;
}
fclose(fp);
dbuf[0] = '\0';
for (i = 0; i < sizeof(buf); i++)
if ((buf[i] >= ' ') && (buf[i] <= 127))
2005-08-29 11:46:06 +00:00
snprintf((char*)dbuf+strlen(dbuf), 80, " %c", buf[i]);
2001-08-17 05:46:24 +00:00
else
2005-08-29 11:46:06 +00:00
snprintf((char*)dbuf+strlen(dbuf), 80, " %02x", buf[i]);
2001-08-17 05:46:24 +00:00
/*
* Various expected uploads. Not that the standard MS-DOS archivers
* must return the exact format, ie "ZIP" for PKZIP. These strings
* are tested against the archivers database. Others that aren't
* compressed files are not important, they just pop up in your
* logfiles.
*/
if (memcmp(buf, "PK\003\004", 4) == 0) return (char *)"ZIP";
if (*buf == 0x1a) return (char *)"ARC";
2002-03-12 19:41:41 +00:00
if (memcmp(buf+2, "-l", 2) == 0) return (char *)"LHA";
2001-08-17 05:46:24 +00:00
if (memcmp(buf, "ZOO", 3) == 0) return (char *)"ZOO";
if (memcmp(buf, "`\352", 2) == 0) return (char *)"ARJ";
if (memcmp(buf, "Rar!", 4) == 0) return (char *)"RAR";
2002-07-27 20:07:12 +00:00
if (memcmp(buf, "HA", 2) == 0) return (char *)"HA";
2001-08-17 05:46:24 +00:00
if (memcmp(buf, "MZ", 2) == 0) return (char *)"EXE";
if (memcmp(buf, "\000\000\001\263", 4) == 0) return (char *)"MPEG";
if (memcmp(buf, "MOVI", 4) == 0) return (char *)"MOVI";
if (memcmp(buf, "\007\007\007", 3) == 0) return (char *)"CPIO";
if (memcmp(buf, "\351,\001JAM", 6) == 0) return (char *)"JAM";
if (memcmp(buf, "SQSH", 4) == 0) return (char *)"SQSH";
if (memcmp(buf, "UC2\0x1a", 4) == 0) return (char *)"UC2";
if (memcmp(buf, ".snd", 4) == 0) return (char *)"SND";
if (memcmp(buf, "MThd", 4) == 0) return (char *)"MID";
if (memcmp(buf, "RIFF", 4) == 0) return (char *)"WAV";
if (memcmp(buf, "EMOD", 4) == 0) return (char *)"MOD";
if (memcmp(buf, "MTM", 3) == 0) return (char *)"MTM";
2001-12-07 22:19:55 +00:00
if (memcmp(buf, "#!/bin/", 7) == 0) return (char *)"UNIX script";
2001-08-17 05:46:24 +00:00
if (memcmp(buf, "\037\235", 2) == 0) return (char *)"Compressed data";
2003-04-12 11:12:26 +00:00
if (memcmp(buf, "\037\213", 2) == 0) return (char *)"GZIP";
2001-08-17 05:46:24 +00:00
if (memcmp(buf, "\177ELF", 4) == 0) return (char *)"ELF";
if (memcmp(buf, "%!", 2) == 0) return (char *)"PostScript";
if (memcmp(buf, "GIF8", 4) == 0) return (char *)"GIF";
if (memcmp(buf, "\377\330\377\340", 4) == 0) return (char *)"JPEG";
if (memcmp(buf, "\377\330\377\356", 4) == 0) return (char *)"JPG";
if (memcmp(buf, "BM", 2) == 0) return (char *)"Bitmap";
if (memcmp(buf, "%PDF", 4) == 0) return (char *)"PDF";
if (memcmp(buf, "THNL", 4) == 0) return (char *)"ThumbNail";
if ((memcmp(buf, "<html>", 6) == 0) ||
(memcmp(buf, "<HTML>", 6) == 0)) return (char *)"HTML";
2002-06-26 21:48:12 +00:00
if (memcmp(buf, "MSCF", 4) == 0) return (char *)"CAB";
if (memcmp(buf, "BZ", 2) == 0) return (char *)"BZIP";
2001-08-17 05:46:24 +00:00
/*
* .COM formats. Should cover about 2/3 of COM files.
*/
if ((*buf == 0xe9) || (*buf == 0x8c) ||
(*buf == 0xeb) || (*buf == 0xb8)) return (char *)"COM";
return NULL;
}
/*
* Import file in area. Returns TRUE if successfull.
*/
2004-11-06 22:01:51 +00:00
int ImportFile(char *fn, int Area, int fileid, off_t Size)
2001-08-17 05:46:24 +00:00
{
2004-11-03 20:48:45 +00:00
char *temp, *temp1, msg[81];
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
temp = calloc(PATH_MAX, sizeof(char));
temp1 = calloc(PATH_MAX, sizeof(char));
2005-08-29 11:46:06 +00:00
snprintf(temp, PATH_MAX, "%s/%s", area.Path, basename(fn));
snprintf(temp1, PATH_MAX, "%s", fn);
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
if ((file_mv(temp1, temp))) {
WriteError("$Can't move %s to %s", fn, area.Path);
} else {
chmod(temp, 0664);
2004-11-06 22:01:51 +00:00
if (Addfile(basename(fn), Area, fileid)) {
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
ReadExitinfo();
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
/*
* If Size is equal to Zero, don't increase file counters else
* Increase file counters if any other size
*/
if (Size) {
exitinfo.Uploads++;
exitinfo.UploadK += (Size / 1024);
exitinfo.UploadKToday += (Size / 1024);
Syslog('b', "Uploads %d, Kb %d, Kb today %d", exitinfo.Uploads, exitinfo.UploadK, exitinfo.UploadKToday);
/* You have */ /* extra download KBytes. */
2005-10-11 20:49:41 +00:00
snprintf(msg, 81, "%s %d %s", (char *) Language(249), (int)(Size / 1024), (char *) Language(250));
2004-11-03 20:48:45 +00:00
PUTSTR(msg);
Enter(1);
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
exitinfo.DownloadKToday += (Size / 1024);
Syslog('b', "DownloadKToday %d", exitinfo.DownloadKToday);
}
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
WriteExitinfo();
free(temp);
free(temp1);
return TRUE;
2001-08-17 05:46:24 +00:00
}
2003-08-03 12:17:35 +00:00
}
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
free(temp);
free(temp1);
return FALSE;
2001-08-17 05:46:24 +00:00
}
/*
* Add file to the FileDataBase. If fileid is true, then try to
* get the filedescription from FILE_ID.DIZ if it is in the
* archive, else the user must supply the description.
* Returns TRUE is successfull.
*/
int Addfile(char *File, int AreaNum, int fileid)
{
2004-05-06 21:33:13 +00:00
FILE *id, *pPrivate;
int err = 1, iDesc = 1, iPrivate = FALSE, GotId = FALSE, lines, i, j;
2005-08-30 19:44:17 +00:00
char *Filename, *temp1, *idname = NULL, *Desc[26], *lname, temp[PATH_MAX], msg[81];
struct stat statfile;
2004-05-06 21:33:13 +00:00
struct _fdbarea *fdb_area = NULL;
2001-08-17 05:46:24 +00:00
Filename = calloc(PATH_MAX, sizeof(char));
temp1 = calloc(PATH_MAX, sizeof(char));
lname = calloc(PATH_MAX, sizeof(char));
2001-08-17 05:46:24 +00:00
2005-08-29 11:46:06 +00:00
snprintf(Filename, PATH_MAX, "%s/%s", area.Path, File);
2001-08-17 05:46:24 +00:00
2004-05-06 21:33:13 +00:00
if ((fdb_area = mbsedb_OpenFDB(AreaNum, 30))) {
/*
* Do a physical check of file to see if it exists
* if it fails it will return a zero which will not
* increase his uploads stats
*/
if (stat(Filename, &statfile) != 0) {
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
Enter(1);
colour(10, 0);
/* Upload was unsuccessful for: */
2005-08-29 11:46:06 +00:00
snprintf(msg, 81, "%s%s", (char *) Language(284), File);
2004-11-03 20:48:45 +00:00
pout(LIGHTGREEN, BLACK, msg);
Enter(2);
2001-08-17 05:46:24 +00:00
2004-05-06 21:33:13 +00:00
mbsedb_CloseFDB(fdb_area);
free(Filename);
free(temp1);
free(lname);
return FALSE;
}
2001-08-17 05:46:24 +00:00
2004-03-06 21:48:41 +00:00
memset(&fdb, 0, fdbhdr.recsize);
2004-12-22 16:13:12 +00:00
strncpy(fdb.LName, File, 80); /* LFN, currently real file */
strcpy(temp1, File);
name_mangle(temp1);
2004-12-22 16:13:12 +00:00
strncpy(fdb.Name, temp1, 12); /* 8.3 name */
2005-10-11 20:49:41 +00:00
fdb.Size = (int)(statfile.st_size);
2004-03-06 21:48:41 +00:00
fdb.FileDate = statfile.st_mtime;
fdb.Crc32 = file_crc(Filename, TRUE);
2004-12-22 16:13:12 +00:00
strncpy(fdb.Uploader, exitinfo.sUserName, 35);
2004-03-06 21:48:41 +00:00
fdb.UploadDate = time(NULL);
if (strcmp(fdb.Name, fdb.LName)) {
2004-11-27 12:32:27 +00:00
/*
* Rename the file first to the 8.3 name, this is the
* standard way to store files in the filebase.
*/
2005-08-29 11:46:06 +00:00
snprintf(lname, PATH_MAX, "%s/%s", area.Path, fdb.Name);
2004-11-27 12:32:27 +00:00
rename(Filename, lname);
/*
* Then make a symlink to the 8.3 name
*/
if (symlink(lname, Filename)) {
WriteError("$Can't create link %s to %s", lname, Filename);
}
}
if (area.PwdUP) {
2004-11-03 20:48:45 +00:00
Enter(1);
/* Do you want to password protect your upload ? [y/N]: */
2004-11-03 20:48:45 +00:00
pout(LIGHTBLUE, BLACK, (char *) Language(285));
2001-08-17 05:46:24 +00:00
2004-11-03 20:48:45 +00:00
if (toupper(Readkey()) == Keystroke(285, 0)) {
Enter(1);
/* REMEMBER: Passwords are "CaSe SeNsITiVe!" */
2004-11-03 20:48:45 +00:00
pout(LIGHTGREEN, BLACK, (char *) Language(286));
Enter(1);
/* Password: */
2004-11-03 20:48:45 +00:00
pout(YELLOW, BLACK, (char *) Language(8));
2004-03-06 21:48:41 +00:00
GetstrC(fdb.Password, 20);
}
}
if (fileid && strlen(archiver.iunarc)) {
/*
* The right unarchiver is still in memory,
* get the FILE_ID.DIZ if it exists.
*/
2005-08-29 11:46:06 +00:00
snprintf(temp, PATH_MAX, "%s/%s", area.Path, File);
2004-03-02 20:47:23 +00:00
if ((err = execute_str(archiver.iunarc, temp, (char *)"FILE_ID.DIZ", (char *)"/dev/null",
(char *)"/dev/null", (char *)"/dev/null"))) {
2004-03-02 20:47:23 +00:00
if ((err = execute_str(archiver.iunarc, temp, (char *)"file_id.diz", (char *)"/dev/null",
(char *)"/dev/null", (char *)"/dev/null"))) {
Syslog('+', "No FILE_ID.DIZ found in %s", File);
} else {
idname = xstrcpy((char *)"file_id.diz");
2001-08-17 05:46:24 +00:00
}
} else {
idname = xstrcpy((char *)"FILE_ID.DIZ");
}
if (!err) {
Syslog('+', "Found %s", idname);
GotId = TRUE;
}
}
2001-08-17 05:46:24 +00:00
if (GotId) {
lines = 0;
if ((id = fopen(idname, "r")) != NULL) {
/*
* Import FILE_ID.DIZ, format to max. 25
* lines, 48 chars width.
*/
while (((fgets(temp1, PATH_MAX -1, id)) != NULL) && (lines < 25)) {
Striplf(temp1);
if (strlen(temp1) > 51) {
2001-08-17 05:46:24 +00:00
/*
* Malformed FILE_ID.DIZ
2001-08-17 05:46:24 +00:00
*/
GotId = FALSE;
for (i = 0; i < 25; i++)
2004-03-06 21:48:41 +00:00
fdb.Desc[i][0] = '\0';
lines = 0;
Syslog('!', "Trashing illegal formatted FILE_ID.DIZ");
break;
}
if (strlen(temp1) > 0) {
j = 0;
for (i = 0; i < strlen(temp1); i++) {
if (isprint(temp1[i])) {
2004-03-06 21:48:41 +00:00
fdb.Desc[lines][j] = temp1[i];
j++;
if (j > 47)
break;
}
2001-08-17 05:46:24 +00:00
}
/*
* Remove trailing spaces
2001-08-17 05:46:24 +00:00
*/
2004-03-06 21:48:41 +00:00
while (j && isspace(fdb.Desc[lines][j-1]))
j--;
2004-03-06 21:48:41 +00:00
fdb.Desc[lines][j] = '\0';
lines++;
}
}
}
fclose(id);
unlink(idname);
if (GotId) {
/*
* Strip empty FILE_ID.DIZ lines at the end
*/
2004-03-06 21:48:41 +00:00
while ((strlen(fdb.Desc[lines-1]) == 0) && (lines)) {
fdb.Desc[lines-1][0] = '\0';
lines--;
}
if (lines) {
Syslog('+', "Using %d FILE_ID.DIZ lines for description", lines);
/* Found FILE_ID.DIZ in */
2005-08-29 11:46:06 +00:00
snprintf(msg, 81, "%s %s", (char *) Language(257), File);
2004-11-03 20:48:45 +00:00
pout(CFG.TextColourF, CFG.TextColourB, msg);
Enter(1);
} else {
Syslog('!', "No FILE_ID.DIZ lines left to use");
GotId = FALSE;
}
}
}
if (!GotId) {
/*
* Ask the user for a description.
*/
for (i = 0; i < 26; i++)
*(Desc + i) = (char *) calloc(49, sizeof(char));
2004-11-03 20:48:45 +00:00
Enter(1);
/* Please enter description of file */
2005-08-29 11:46:06 +00:00
snprintf(msg, 81, "%s %s", (char *) Language(287), File);
2004-11-03 20:48:45 +00:00
pout(LIGHTRED, BLACK, msg);
Enter(2);
while (TRUE) {
2005-08-29 11:46:06 +00:00
snprintf(msg, 81, "%2d> ", iDesc);
2004-11-03 20:48:45 +00:00
pout(LIGHTGREEN, BLACK, msg);
colour(CFG.InputColourF, CFG.InputColourB);
GetstrC(*(Desc + iDesc), 47);
2001-08-17 05:46:24 +00:00
if ((strcmp(*(Desc + iDesc), "")) == 0)
break;
2001-08-17 05:46:24 +00:00
iDesc++;
2001-08-17 05:46:24 +00:00
if (iDesc >= 26)
break;
}
2001-08-17 05:46:24 +00:00
for (i = 1; i < iDesc; i++)
2004-03-06 21:48:41 +00:00
strcpy(fdb.Desc[i - 1], Desc[i]);
2001-08-17 05:46:24 +00:00
for (i = 0; i < 26; i++)
free(Desc[i]);
}
2001-08-17 05:46:24 +00:00
/*
* Log upload before adding to the filebase, after insert the fdb record
* is overwritten.
*/
2005-08-29 11:46:06 +00:00
snprintf(temp, PATH_MAX, "%s/log/uploads.log", getenv("MBSE_ROOT"));
if ((pPrivate = fopen(temp, "a+")) == NULL)
WriteError("$Can't open %s", temp);
else {
iPrivate = TRUE;
fprintf(pPrivate, "****************************************************");
2004-03-06 21:48:41 +00:00
fprintf(pPrivate, "\nUser : %s", fdb.Uploader);
fprintf(pPrivate, "\nFile : %s (%s)", fdb.LName, fdb.Name);
2005-10-11 20:49:41 +00:00
fprintf(pPrivate, "\nSize : %u", (int)(fdb.Size));
2004-03-06 21:48:41 +00:00
fprintf(pPrivate, "\nUpload Date : %s\n\n", StrDateDMY(fdb.UploadDate));
2001-08-17 05:46:24 +00:00
for (i = 0; i < iDesc - 1; i++)
2004-03-06 21:48:41 +00:00
fprintf(pPrivate, "%2d: %s\n", i, fdb.Desc[i]);
2001-08-17 05:46:24 +00:00
fclose(pPrivate);
2001-08-17 05:46:24 +00:00
}
mbsedb_InsertFDB(fdb_area, fdb, area.AddAlpha);
mbsedb_CloseFDB(fdb_area);
Enter(1);
/* Your upload time has been returned to you. Thank you for your upload! */
2004-11-03 20:48:45 +00:00
pout(LIGHTGREEN, BLACK, (char *) Language(288));
Enter(1);
}
free(Filename);
free(temp1);
return TRUE;
2001-08-17 05:46:24 +00:00
}
/*
* Set file area number, set global area description and path.
*/
2005-10-11 20:49:41 +00:00
void SetFileArea(unsigned int AreaNum)
2001-08-17 05:46:24 +00:00
{
2003-08-03 12:17:35 +00:00
FILE *pArea;
2005-10-11 20:49:41 +00:00
int offset;
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
memset(&area, 0, sizeof(area));
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
if ((pArea = OpenFareas(FALSE)) == NULL)
return;
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
offset = areahdr.hdrsize + ((AreaNum - 1) * areahdr.recsize);
if (fseek(pArea, offset, 0) != 0) {
WriteError("$Seek error in fareas.data, area %ld", AreaNum);
return;
}
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
fread(&area, areahdr.recsize, 1, pArea);
strcpy(sAreaDesc, area.Name);
strcpy(sAreaPath, area.Path);
iAreaNumber = AreaNum;
fclose(pArea);
2001-08-17 05:46:24 +00:00
}
2003-08-03 12:17:35 +00:00
/*
* Return size in bytes of all files in the users wrk directory.
*/
2005-10-11 20:49:41 +00:00
unsigned int Quota()
2001-08-17 05:46:24 +00:00
{
2003-08-03 12:17:35 +00:00
DIR *dirp;
char *FileName, *temp;
2005-10-11 20:49:41 +00:00
unsigned int Bytes = 0;
2003-08-03 12:17:35 +00:00
struct dirent *dp;
struct stat statfile;
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
FileName = calloc(PATH_MAX, sizeof(char));
temp = calloc(PATH_MAX, sizeof(char));
2005-08-29 11:46:06 +00:00
snprintf(temp, PATH_MAX, "%s/%s/wrk", CFG.bbs_usersdir, exitinfo.Name);
2003-08-03 12:17:35 +00:00
if ((dirp = opendir(temp)) == NULL) {
WriteError("$Can't open dir %s", temp);
} else {
while ((dp = readdir(dirp)) != NULL) {
2005-08-29 11:46:06 +00:00
snprintf(FileName, PATH_MAX, "%s/%s", temp, dp->d_name);
2003-08-03 12:17:35 +00:00
if (*(dp->d_name) != '.')
if (stat(FileName, &statfile) == 0)
Bytes += statfile.st_size;
2001-08-17 05:46:24 +00:00
}
2003-08-03 12:17:35 +00:00
closedir(dirp);
}
free(FileName);
free(temp);
return Bytes;
2001-08-17 05:46:24 +00:00
}
void ImportHome(char *fn)
{
2003-08-03 12:17:35 +00:00
char *temp1, *temp2;
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
temp1 = calloc(PATH_MAX, sizeof(char));
temp2 = calloc(PATH_MAX, sizeof(char));
2005-08-29 11:46:06 +00:00
snprintf(temp1, PATH_MAX, "%s/%s/wrk/%s", CFG.bbs_usersdir, exitinfo.Name, fn);
snprintf(temp2, PATH_MAX, "%s/%s/upl/%s", CFG.bbs_usersdir, exitinfo.Name, fn);
2001-08-17 05:46:24 +00:00
2003-08-03 12:17:35 +00:00
Syslog('+', "Move %s to home, result %d", fn, file_mv(temp2, temp1));
free(temp1);
free(temp2);
2001-08-17 05:46:24 +00:00
}