static void filter_request(char *buf)
{
int msg_type = CVAL(buf,0);
int type = CVAL(buf,smb_com);
pstring name1,name2;
unsigned x;
if (msg_type) {
/* it's a netbios special */
switch (msg_type) {
case 0x81:
/* session request */
name_extract(buf,4,name1);
name_extract(buf,4 + name_len(buf + 4),name2);
DEBUG(0,("sesion_request: %s -> %s\n",
name1, name2));
if (netbiosname) {
/* replace the destination netbios name */
name_mangle(netbiosname, buf+4, 0x20);
}
}
return;
}
/* it's an ordinary SMB request */
switch (type) {
case SMBsesssetupX:
/* force the client capabilities */
x = IVAL(buf,smb_vwv11);
x = (x | CLI_CAPABILITY_SET) & ~CLI_CAPABILITY_MASK;
SIVAL(buf, smb_vwv11, x);
break;
}
}
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);
}
String *Swig_name_mangle(const_String_or_char_ptr s) {
#if 0
String *r = NewString(s);
name_mangle(r);
return r;
#else
return Swig_string_mangle(s);
#endif
}
String *
Swig_name_wrapper(const String_or_char *fname) {
String *r;
String *f;
r = NewString("");
if (!naming_hash) naming_hash = NewHash();
f = Getattr(naming_hash,"wrapper");
if (!f) {
Append(r,"_wrap_%f");
} else {
Append(r,f);
}
Replace(r,"%f",fname, DOH_REPLACE_ANY);
name_mangle(r);
return r;
}
static void filter_request(char *buf)
{
int msg_type = CVAL(buf,0);
int type = CVAL(buf,smb_com);
pstring name1,name2;
unsigned x;
if (msg_type) {
/* it's a netbios special */
switch (msg_type) {
case 0x81:
/* session request */
name_extract(buf,4,name1);
name_extract(buf,4 + name_len(buf + 4),name2);
d_printf("sesion_request: %s -> %s\n",
name1, name2);
if (netbiosname) {
/* replace the destination netbios name */
name_mangle(netbiosname, buf+4, 0x20);
}
}
return;
}
/* it's an ordinary SMB request */
switch (type) {
case SMBsesssetupX:
/* force the client capabilities */
x = IVAL(buf,smb_vwv11);
d_printf("SMBsesssetupX cap=0x%08x\n", x);
d_printf("pwlen=%d/%d\n", SVAL(buf, smb_vwv7), SVAL(buf, smb_vwv8));
system("mv sessionsetup.dat sessionsetup1.dat");
save_file("sessionsetup.dat", smb_buf(buf), SVAL(buf, smb_vwv7));
x = (x | CLI_CAPABILITY_SET) & ~CLI_CAPABILITY_MASK;
SIVAL(buf, smb_vwv11, x);
break;
}
}
static void filter_request(char *buf, size_t buf_len)
{
int msg_type = CVAL(buf,0);
int type = CVAL(buf,smb_com);
unsigned x;
fstring name1,name2;
int name_len1, name_len2;
int name_type1, name_type2;
if (msg_type) {
/* it's a netbios special */
switch (msg_type)
case 0x81:
/* session request */
/* inbuf_size is guaranteed to be at least 4. */
name_len1 = name_len((unsigned char *)(buf+4),
buf_len - 4);
if (name_len1 <= 0 || name_len1 > buf_len - 4) {
DEBUG(0,("Invalid name length in session request\n"));
return;
}
name_len2 = name_len((unsigned char *)(buf+4+name_len1),
buf_len - 4 - name_len1);
if (name_len2 <= 0 || name_len2 > buf_len - 4 - name_len1) {
DEBUG(0,("Invalid name length in session request\n"));
return;
}
name_type1 = name_extract((unsigned char *)buf,
buf_len,(unsigned int)4,name1);
name_type2 = name_extract((unsigned char *)buf,
buf_len,(unsigned int)(4 + name_len1),name2);
if (name_type1 == -1 || name_type2 == -1) {
DEBUG(0,("Invalid name type in session request\n"));
return;
}
d_printf("sesion_request: %s -> %s\n",
name1, name2);
if (netbiosname) {
char *mangled = name_mangle(
talloc_tos(), netbiosname, 0x20);
if (mangled != NULL) {
/* replace the destination netbios
* name */
memcpy(buf+4, mangled,
name_len((unsigned char *)mangled,
talloc_get_size(mangled)));
TALLOC_FREE(mangled);
}
}
return;
}
/* it's an ordinary SMB request */
switch (type) {
case SMBsesssetupX:
/* force the client capabilities */
x = IVAL(buf,smb_vwv11);
d_printf("SMBsesssetupX cap=0x%08x\n", x);
d_printf("pwlen=%d/%d\n", SVAL(buf, smb_vwv7), SVAL(buf, smb_vwv8));
system("mv sessionsetup.dat sessionsetup1.dat");
save_file("sessionsetup.dat", smb_buf(buf), SVAL(buf, smb_vwv7));
x = (x | CLI_CAPABILITY_SET) & ~CLI_CAPABILITY_MASK;
SIVAL(buf, smb_vwv11, x);
break;
}
}
/****************************************************************************
send a session request. see rfc1002.txt 4.3 and 4.3.2
****************************************************************************/
BOOL cli_session_request(struct cli_state *cli,
const struct nmb_name *calling,
const struct nmb_name *called)
{
char *p;
int len = 4;
extern pstring user_socket_options;
io_struct ps;
uchar nb_type;
ZERO_STRUCT(ps);
io_init(&ps, 4096, MARSHALL);
/* send a session request (RFC 1002) */
smb_set_nbnames(cli->hnd, calling, called);
/* put in the destination name */
p = ps.data_p;
name_mangle(called->name, p, called->name_type);
len += name_len(p);
/* and my name */
p = ps.data_p + len-4;
name_mangle(calling->name, p, calling->name_type);
len += name_len(p);
ps.data_offset = len;
smb_send_smb(cli->hnd, &ps, 0x81);
io_free(&ps);
DEBUG(5, ("Sent session request: %s to %s\n",
nmb_namestr(calling), nmb_namestr(called)));
if (!smb_receive_smb(cli->hnd, &ps, &nb_type))
return False;
if (nb_type == 0x84)
{
int fd;
/* C. Hoch 9/14/95 Start */
/* For information, here is the response structure.
* We do the byte-twiddling to for portability.
struct RetargetResponse{
unsigned char type;
unsigned char flags;
int16 length;
int32 ip_addr;
int16 port;
};
*/
int port = (CVAL(ps.data_p, 4) << 8) + CVAL(ps.data_p, 5);
/* SESSION RETARGET */
putip((char *)&cli->dest_ip, ps.data_p);
fd = open_socket_out(SOCK_STREAM, &cli->dest_ip, port,
LONG_CONNECT_TIMEOUT);
if (fd == -1 || !smb_set_fd(cli->hnd, fd))
return False;
cli->dbg(3, "Retargeted\n");
set_socket_options(fd, user_socket_options);
/* Try again */
{
static int depth;
BOOL ret;
if (depth > 4)
{
cli->dbg( 0,
"Retarget recursion - failing\n");
return False;
}
depth++;
ret = cli_session_request(cli, calling, called);
depth--;
return ret;
}
} /* C. Hoch 9/14/95 End */
if (nb_type != 0x82)
{
/* This is the wrong place to put the error... JRA. */
cli->rap_error = CVAL(ps.data_p, 0);
return False;
}
return (True);
}
BOOL cli_session_request(struct cli_state *cli,
struct nmb_name *calling, struct nmb_name *called)
{
char *p;
int len = 4;
extern pstring user_socket_options;
/* 445 doesn't have session request */
if (cli->port == 445) return True;
/* send a session request (RFC 1002) */
memcpy(&(cli->calling), calling, sizeof(*calling));
memcpy(&(cli->called ), called , sizeof(*called ));
/* put in the destination name */
p = cli->outbuf+len;
name_mangle(cli->called .name, p, cli->called .name_type);
len += name_len(p);
/* and my name */
p = cli->outbuf+len;
name_mangle(cli->calling.name, p, cli->calling.name_type);
len += name_len(p);
/* setup the packet length
* Remove four bytes from the length count, since the length
* field in the NBT Session Service header counts the number
* of bytes which follow. The cli_send_smb() function knows
* about this and accounts for those four bytes.
* CRH.
*/
len -= 4;
_smb_setlen(cli->outbuf,len);
SCVAL(cli->outbuf,0,0x81);
#ifdef WITH_SSL
retry:
#endif /* WITH_SSL */
cli_send_smb(cli);
DEBUG(5,("Sent session request\n"));
if (!cli_receive_smb(cli))
return False;
if (CVAL(cli->inbuf,0) == 0x84) {
/* C. Hoch 9/14/95 Start */
/* For information, here is the response structure.
* We do the byte-twiddling to for portability.
struct RetargetResponse{
unsigned char type;
unsigned char flags;
int16 length;
int32 ip_addr;
int16 port;
};
*/
int port = (CVAL(cli->inbuf,8)<<8)+CVAL(cli->inbuf,9);
/* SESSION RETARGET */
putip((char *)&cli->dest_ip,cli->inbuf+4);
cli->fd = open_socket_out(SOCK_STREAM, &cli->dest_ip, port, LONG_CONNECT_TIMEOUT);
if (cli->fd == -1)
return False;
DEBUG(3,("Retargeted\n"));
set_socket_options(cli->fd,user_socket_options);
/* Try again */
{
static int depth;
BOOL ret;
if (depth > 4) {
DEBUG(0,("Retarget recursion - failing\n"));
return False;
}
depth++;
ret = cli_session_request(cli, calling, called);
depth--;
return ret;
}
} /* C. Hoch 9/14/95 End */
#ifdef WITH_SSL
if (CVAL(cli->inbuf,0) == 0x83 && CVAL(cli->inbuf,4) == 0x8e){ /* use ssl */
if (!sslutil_fd_is_ssl(cli->fd)){
if (sslutil_connect(cli->fd) == 0)
goto retry;
}
}
#endif /* WITH_SSL */
if (CVAL(cli->inbuf,0) != 0x82) {
/* This is the wrong place to put the error... JRA. */
cli->rap_error = CVAL(cli->inbuf,4);
return False;
}
return(True);
}
void AdoptFile(int Area, char *File, char *Description)
{
FILE *fp;
char *temp, *temp2, *tmpdir, *unarc, *pwd, *lname, *fileid;
char Desc[256], TDesc[256];
int MustRearc = FALSE, UnPacked = FALSE;
int IsVirus = FALSE, File_Id = FALSE;
int i, j, k, lines = 0, File_id_cnt = 0;
struct FILE_record f_db;
Syslog('f', "Adopt(%d, %s, %s)", Area, FTND_SS(File), FTND_SS(Description));
if (!do_quiet)
ftnd_colour(CYAN, BLACK);
if (LoadAreaRec(Area) == FALSE)
die(FTNERR_INIT_ERROR);
if (area.Available) {
temp = calloc(PATH_MAX, sizeof(char));
temp2 = calloc(PATH_MAX, sizeof(char));
pwd = calloc(PATH_MAX, sizeof(char));
tmpdir = calloc(PATH_MAX, sizeof(char));
if (CheckFDB(Area, area.Path))
die(FTNERR_INIT_ERROR);
getcwd(pwd, PATH_MAX);
if (!do_quiet) {
printf("Adopt file: %s ", File);
printf("Unpacking \b\b\b\b\b\b\b\b\b\b");
fflush(stdout);
}
snprintf(tmpdir, PATH_MAX, "%s/tmp/arc%d", getenv("FTND_ROOT"), (int)getpid());
if (create_tmpwork()) {
WriteError("Can't create %s", tmpdir);
if (!do_quiet)
printf("\nCan't create dir %s\n", tmpdir);
die(FTNERR_INIT_ERROR);
}
snprintf(temp, PATH_MAX, "%s/%s", pwd, File);
if (do_novir == FALSE) {
if (!do_quiet) {
printf("Virscan \b\b\b\b\b\b\b\b\b\b");
fflush(stdout);
}
IsVirus = VirScanFile(temp);
}
if (IsVirus) {
WriteError("Virus found");
if (!do_quiet)
printf("\nVirus found\n");
die(FTNERR_VIRUS_FOUND);
}
if ((unarc = unpacker(File))) {
if (strlen(area.Archiver) && (strcmp(unarc, area.Archiver) == 0))
MustRearc = TRUE;
UnPacked = UnpackFile(temp);
if (!UnPacked)
die(FTNERR_INIT_ERROR);
}
if (!do_quiet) {
printf("Checking \b\b\b\b\b\b\b\b\b\b");
fflush(stdout);
}
memset(&f_db, 0, sizeof(f_db));
strcpy(f_db.Uploader, CFG.sysop_name);
f_db.UploadDate = time(NULL);
if (do_annon)
f_db.Announced = TRUE;
if (UnPacked) {
/*
* Try to get a FILE_ID.DIZ
*/
fileid = calloc(PATH_MAX, sizeof(char));
snprintf(temp, PATH_MAX, "%s/tmp/arc%d", getenv("FTND_ROOT"), (int)getpid());
snprintf(fileid, PATH_MAX, "FILE_ID.DIZ");
if (getfilecase(temp, fileid)) {
snprintf(temp, PATH_MAX, "%s/tmp/arc%d/%s", getenv("FTND_ROOT"), (int)getpid(), fileid);
snprintf(temp2, PATH_MAX, "%s/tmp/FILE_ID.DIZ", getenv("FTND_ROOT"));
if (file_cp(temp, temp2) == 0) {
File_Id = TRUE;
}
}
free(fileid);
if (File_Id) {
Syslog('f', "FILE_ID.DIZ found");
if ((fp = fopen(temp2, "r"))) {
/*
* Read no more then 25 lines
*/
while (((fgets(Desc, 255, fp)) != NULL) && (File_id_cnt < 25)) {
lines++;
/*
* Check if the FILE_ID.DIZ is in a normal layout.
* This should be max. 10 lines of max. 48 characters.
* We check at 51 characters and if the lines are longer,
* we discard the FILE_ID.DIZ file.
*/
if (strlen(Desc) > 51) {
File_id_cnt = 0;
File_Id = FALSE;
Syslog('!', "Discarding illegal formated FILE_ID.DIZ");
break;
}
if (strlen(Desc)) {
if (strlen(Desc) > 48)
Desc[48] = '\0';
j = 0;
for (i = 0; i < strlen(Desc); i++) {
if ((Desc[i] >= ' ') || (Desc[i] < 0)) {
f_db.Desc[File_id_cnt][j] = Desc[i];
j++;
}
}
File_id_cnt++;
}
}
fclose(fp);
unlink(temp2);
/*
* Strip empty lines at end of FILE_ID.DIZ
*/
while ((strlen(f_db.Desc[File_id_cnt-1]) == 0) && (File_id_cnt))
File_id_cnt--;
Syslog('f', "Got %d FILE_ID.DIZ lines", File_id_cnt);
for (i = 0; i < File_id_cnt; i++)
Syslog('f', "\"%s\"", f_db.Desc[i]);
}
}
}
if (!File_id_cnt) {
if (Description == NULL) {
WriteError("No FILE_ID.DIZ and no description on the commandline");
if (!do_quiet)
printf("\nNo FILE_ID.DIZ and no description on the commandline\n");
clean_tmpwork();
die(FTNERR_COMMANDLINE);
} else {
/*
* Create description from the commandline.
*/
if (strlen(Description) < 48) {
/*
* Less then 48 chars, copy and ready.
*/
strcpy(f_db.Desc[0], Description);
File_id_cnt++;
} else {
/*
* More then 48 characters, break into multiple
* lines not longer then 48 characters.
*/
memset(&TDesc, 0, sizeof(TDesc));
strcpy(TDesc, Description);
while (strlen(TDesc) > 48) {
j = 48;
while (TDesc[j] != ' ')
j--;
strncat(f_db.Desc[File_id_cnt], TDesc, j);
File_id_cnt++;
k = strlen(TDesc);
j++; /* Correct space */
for (i = 0; i <= k; i++, j++)
TDesc[i] = TDesc[j];
}
strcpy(f_db.Desc[File_id_cnt], TDesc);
File_id_cnt++;
}
}
}
/*
* Import the file.
*/
chdir(pwd);
clean_tmpwork();
/*
* Work out the kind of filename, is it a long filename
* or a 8.3 DOS filename. The file on disk must become
* 8.3 for import.
*/
if (is_real_8_3(File)) {
Syslog('f', "Adopt, file is 8.3");
strcpy(f_db.Name, File);
strcpy(f_db.LName, File);
for (i = 0; i < strlen(File); i++)
if (isupper(f_db.LName[i]))
f_db.LName[i] = tolower(f_db.LName[i]);
} else {
Syslog('f', "Adopt, file is LFN");
strcpy(temp2, File);
name_mangle(temp2);
if (rename(File, temp2)) {
Syslog('+', "Can't rename %s to %s", File, temp2);
if (!do_quiet)
printf("\nCan't rename %s to %s\n", File, temp2);
die(FTNERR_GENERAL);
}
strcpy(f_db.Name, temp2);
strcpy(f_db.LName, File);
}
f_db.Size = file_size(f_db.Name);
f_db.Crc32 = file_crc(f_db.Name, TRUE);
f_db.FileDate = file_time(f_db.Name);
snprintf(temp2, PATH_MAX, "%s/%s", area.Path, f_db.Name);
if (!do_quiet) {
printf("Adding \b\b\b\b\b\b\b\b\b\b");
fflush(stdout);
}
if (strcmp(f_db.Name, f_db.LName)) {
lname = calloc(PATH_MAX, sizeof(char));
snprintf(lname, PATH_MAX, "%s/%s", area.Path, f_db.LName);
if (AddFile(f_db, Area, temp2, f_db.Name, lname) == FALSE) {
die(FTNERR_GENERAL);
}
free(lname);
} else {
if (AddFile(f_db, Area, temp2, File, NULL) == FALSE) {
die(FTNERR_GENERAL);
}
}
Syslog('+', "File %s added to area %d", File, Area);
if (MustRearc) {
/* Here we should call the rearc function */
}
free(pwd);
free(temp2);
free(temp);
free(tmpdir);
} else {
WriteError("Area %d is not available", Area);
if (!do_quiet)
printf("\nArea %d is not available\n", Area);
}
if (!do_quiet) {
printf("\r \r");
fflush(stdout);
}
}
/*
* Returns > 0 if error, 0 if ok.
*/
int LoadTic(char *inb, char *tfn, orphans **opl)
{
FILE *tfp;
char *Temp, *Temp2, *Buf, *Log = NULL, RealName[256];
int i, j, rc, bufsize, DescCnt = FALSE;
fa_list *sbl = NULL;
if (CFG.slow_util && do_quiet)
msleep(1);
memset(&RealName, 0, sizeof(RealName));
memset(&TIC, 0, sizeof(TIC));
memset(&T_File, 0, sizeof(T_File));
snprintf(TIC.Inbound, PATH_MAX, "%s", inb);
strncpy(TIC.TicName, tfn, 12);
chdir(inb);
if ((tfp = fopen(tfn, "r")) == NULL) {
WriteError("$Cannot open %s", tfn);
return 1;
}
/*
* Although a TIC line may only be 255 characters long,
* nobody seems to care and lines are up to 1024 characters
* long.
*/
if (PATH_MAX > 1024)
bufsize = PATH_MAX;
else
bufsize = 1024;
Temp = calloc(bufsize+1, sizeof(char));
Buf = calloc(bufsize+1, sizeof(char));
while ((fgets(Buf, bufsize, tfp)) != NULL) {
if (strlen(Buf) == bufsize)
Syslog('!', "Detected a TIC file line of %d characters long", bufsize);
/*
* Remove all garbage from this tic line.
*/
Temp[0] = '\0';
j = 0;
for (i = 0; i < strlen(Buf); i++) {
if (isprint(Buf[i] & 0x7f)) {
Temp[j] = Buf[i] & 0x7f;
j++;
}
}
Temp[j] = '\0';
if (strncasecmp(Temp, "hatch", 5) == 0) {
TIC.TicIn.Hatch = TRUE;
} else if (TIC.TicIn.Hatch && (strncasecmp(Temp, "pth ", 4) == 0)) {
strncpy(TIC.TicIn.Pth, Temp+4, PATH_MAX);
} else if (strncasecmp(Temp, "area ", 5) == 0) {
strncpy(TIC.TicIn.Area, Temp+5, 20);
strncpy(T_File.Echo, Temp+5, 20);
} else if (strncasecmp(Temp, "origin ", 7) == 0) {
strncpy(TIC.TicIn.Origin, Temp+7, 80);
strncpy(T_File.Origin, Temp+7, 23);
} else if (strncasecmp(Temp, "from ", 5) == 0) {
strncpy(TIC.TicIn.From, Temp+5, 80);
strncpy(T_File.From, Temp+5, 23);
} else if (strncasecmp(Temp, "file ", 5) == 0) {
strncpy(TIC.TicIn.File, Temp+5, 80);
for (i = 0; i < strlen(TIC.TicIn.File); i++)
TIC.TicIn.File[i] = toupper(TIC.TicIn.File[i]);
} else if (strncasecmp(Temp, "fullname ", 9) == 0) {
strncpy(TIC.TicIn.FullName, Temp+9, 80);
} else if (strncasecmp(Temp, "created ", 8) == 0) {
strncpy(TIC.TicIn.Created, Temp+8, 80);
} else if (strncasecmp(Temp, "magic ", 6) == 0) {
strncpy(TIC.TicIn.Magic, Temp+6, 20);
strncpy(T_File.Magic, Temp+6, 20);
} else if (strncasecmp(Temp, "crc ", 4) == 0) {
TIC.Crc_Int = strtoul(Temp+4, (char **)NULL, 16);
snprintf(TIC.TicIn.Crc, 9, "%08X", TIC.Crc_Int);
strncpy(T_File.Crc, TIC.TicIn.Crc, 8);
} else if (strncasecmp(Temp, "pw ", 3) == 0) {
strncpy(TIC.TicIn.Pw, Temp+3, 20);
} else if (strncasecmp(Temp, "replaces ", 9) == 0) {
strncpy(TIC.TicIn.Replace, Temp+9, 80);
strncpy(T_File.Replace, Temp+9, 80);
} else if (strncasecmp(Temp, "desc ", 5) == 0) {
if (!DescCnt) {
strncpy(TIC.TicIn.Desc, Temp+5, 1023);
strncpy(T_File.Desc, TIC.TicIn.Desc, 255);
DescCnt = TRUE;
} else {
Syslog('!', "More than one \"Desc\" line");
}
} else if (strncasecmp(Temp, "path ", 5) == 0) {
if (strchr(Temp+5, ':') && strchr(Temp+5, '/')) {
strncpy(TIC.TicIn.Path[TIC.TicIn.TotPath], Temp+5, 80);
TIC.TicIn.TotPath++;
TIC.Aka.zone = atoi(strtok(Temp+5, ":"));
TIC.Aka.net = atoi(strtok(NULL, "/"));
TIC.Aka.node = atoi(strtok(NULL, "\0"));
for (i = 0; i < 40; i++)
if ((CFG.akavalid[i]) && (CFG.aka[i].zone == TIC.Aka.zone) && (CFG.aka[i].net == TIC.Aka.net) &&
(CFG.aka[i].node == TIC.Aka.node) && (!CFG.aka[i].point)) {
TIC.TicIn.PathError = TRUE;
Syslog('+', "Aka %d: %s in path", i + 1, aka2str(CFG.aka[i]));
}
} else {
WriteError("No valid AKA in Path line: \"%s\"", printable(Temp, 0));
WriteError("Report this to author of that program");
}
} else if (strncasecmp(Temp, "seenby ", 7) == 0) {
if (strchr(Temp+7, ':') && strchr(Temp+7, '/')) {
fill_list(&sbl, Temp+7, NULL);
} else {
WriteError("No valid AKA in Seenby line: \"%s\"", printable(Temp, 0));
}
} else if (strncasecmp(Temp, "areadesc ", 9) == 0) {
strncpy(TIC.TicIn.AreaDesc, Temp+9, 60);
} else if (strncasecmp(Temp, "to ", 3) == 0) {
/*
* Drop this one
* FIXME: should check if this is for us.
*/
} else if (strncasecmp(Temp, "size ", 5) == 0) {
TIC.TicIn.Size = atoi(Temp+5);
} else if (strncasecmp(Temp, "date ", 5) == 0) {
/*
* Drop this one (HTick writes these)
*/
} else if (strncasecmp(Temp, "cost ", 5) == 0) {
TIC.TicIn.Cost = atoi(Temp+5);
} else if (strncasecmp(Temp, "ldesc ", 6) == 0) {
if (TIC.TicIn.TotLDesc < 25) {
strncpy(TIC.TicIn.LDesc[TIC.TicIn.TotLDesc], Temp+6, 80);
TIC.TicIn.TotLDesc++;
} else {
Syslog('f', "Too many LDesc lines in TIC file");
}
} else if (strncasecmp(Temp, "destination ", 12) == 0) {
/*
* Drop this one
*/
} else {
/*
* If we didn't find a matching keyword it is a line we
* will just remember and forward if there are downlinks.
*/
if (strlen(Temp) > 127) {
Syslog('+', "Unknown too long TIC line dropped");
} else if (TIC.TicIn.Unknowns < 25) {
strncpy(TIC.TicIn.Unknown[TIC.TicIn.Unknowns], Temp, 127);
TIC.TicIn.Unknowns++;
}
}
}
fclose(tfp);
/*
* Do some basic checks on the loaded ticfile.
*/
if ( (strlen(TIC.TicIn.File) == 0) || (strlen(TIC.TicIn.Area) == 0) ||
(strlen(TIC.TicIn.From) == 0) || (strlen(TIC.TicIn.Origin) == 0)) {
WriteError("TIC file %s misses important information", TIC.TicName);
tidy_falist(&sbl);
mover(TIC.TicName);
tic_in++;
tic_bad++;
return 1;
}
if (TIC.TicIn.TotLDesc) {
/*
* First check for a bug in Harald Harms Allfix program that
* lets Allfix forward dummy Ldesc lines with the contents:
* "Long description not available"
*/
if (strstr(TIC.TicIn.LDesc[0], "ion not avail") != NULL) {
Syslog('!', "Killing invalid Ldesc line(s)");
TIC.TicIn.TotLDesc = 0;
}
}
if (TIC.TicIn.TotLDesc) {
T_File.TotLdesc = TIC.TicIn.TotLDesc;
for (i = 0; i < TIC.TicIn.TotLDesc; i++) {
strncpy(T_File.LDesc[i], TIC.TicIn.LDesc[i], 48);
}
}
/*
* Show on screen what we are doing
*/
if (!do_quiet) {
ftnd_colour(CYAN, BLACK);
printf("\r");
for (i = 0; i < 79; i++)
printf(" ");
printf("\rTic: %12s File: %-14s Area: %-12s ", TIC.TicName, TIC.TicIn.File, TIC.TicIn.Area);
fflush(stdout);
}
/*
* Show in logfile what we are doing
*/
Syslog('+', "Processing %s, %s area %s from %s", TIC.TicName, TIC.TicIn.File, TIC.TicIn.Area, TIC.TicIn.From);
Syslog('+', "+- %s", TIC.TicIn.Created);
Log = NULL;
if (strlen(TIC.TicIn.Replace)) {
Log = xstrcpy((char *)"Replace ");
Log = xstrcat(Log, TIC.TicIn.Replace);
}
if (strlen(TIC.TicIn.Magic)) {
if (Log != NULL)
Log = xstrcat(Log, (char *)", Magic ");
else
Log = xstrcpy((char *)"Magic ");
Log = xstrcat(Log, TIC.TicIn.Magic);
}
if (Log != NULL) {
Syslog('+', "%s", Log);
free(Log);
Log = NULL;
}
strcpy(Temp, TIC.TicIn.From);
TIC.Aka.zone = atoi(strtok(Temp, ":"));
TIC.Aka.net = atoi(strtok(NULL, "/"));
TIC.Aka.node = atoi(strtok(NULL, "@\0"));
if (SearchFidonet(TIC.Aka.zone))
strcpy(TIC.Aka.domain, fidonet.domain);
strcpy(Temp, TIC.TicIn.Origin);
TIC.OrgAka.zone = atoi(strtok(Temp, ":"));
TIC.OrgAka.net = atoi(strtok(NULL, "/"));
TIC.OrgAka.node = atoi(strtok(NULL, "@\0"));
if (SearchFidonet(TIC.OrgAka.zone))
strcpy(TIC.OrgAka.domain, fidonet.domain);
Temp2 = calloc(PATH_MAX, sizeof(char));
if (TIC.TicIn.Hatch) {
/*
* Try to move the hatched file to the inbound
*/
snprintf(Temp, bufsize, "%s/%s", TIC.TicIn.Pth, TIC.TicIn.FullName);
if (file_exist(Temp, R_OK) == 0) {
strcpy(RealName, TIC.TicIn.FullName);
} else {
WriteError("Can't find %s", Temp);
tidy_falist(&sbl);
return 2;
}
snprintf(Temp2, PATH_MAX, "%s/%s", TIC.Inbound, TIC.TicIn.FullName);
if ((rc = file_mv(Temp, Temp2))) {
WriteError("Can't move %s to inbound: %s", Temp, strerror(rc));
tidy_falist(&sbl);
return 1;
}
if (!strlen(TIC.TicIn.File)) {
strcpy(Temp, TIC.TicIn.FullName);
name_mangle(Temp);
strncpy(TIC.TicIn.File, Temp, 12);
Syslog('f', "Local hatch created 8.3 name %s", Temp);
}
} else {
/*
* Find out what the real name of the file is,
* most likely this is a 8.3 filename.
*/
strncpy(RealName, TIC.TicIn.File, 255);
Syslog('f', "getfilecase(%s, %s)", TIC.Inbound, RealName);
if (! getfilecase(TIC.Inbound, RealName)) {
strncpy(RealName, TIC.TicIn.FullName, 255);
Syslog('f', "getfilecase(%s, %s)", TIC.Inbound, RealName);
if (! getfilecase(TIC.Inbound, RealName)) {
memset(&RealName, 0, sizeof(RealName));
}
}
}
if (strlen(RealName) == 0) {
/*
* We leave RealName empty, the ProcessTic function
* will handle this orphaned tic file.
*/
TIC.Orphaned = TRUE;
Syslog('+', "Can't find file in inbound, will check later");
} else {
/*
* If no LFN received in the ticfile and the file in the inbound is the same as the 8.3 name
* but only the case is different, then treat the real filename as LFN.
*/
if ((strlen(TIC.TicIn.FullName) == 0) && strcmp(TIC.TicIn.File, RealName) && (strcasecmp(TIC.TicIn.File, RealName) == 0)) {
Syslog('f', "Real filename possible LFN, faking it");
strcpy(TIC.TicIn.FullName, RealName);
}
Syslog('f', "Real filename in inbound is \"%s\"", RealName);
if ((strlen(TIC.TicIn.FullName)) == 0) {
Syslog('f', "LFN is empty, create lowercase one");
strncpy(TIC.TicIn.FullName, RealName, 255);
for (i = 0; i < strlen(TIC.TicIn.FullName); i++)
TIC.TicIn.FullName[i] = tolower(TIC.TicIn.FullName[i]);
}
Syslog('+', "8.3 name \"%s\", LFN \"%s\"", TIC.TicIn.File, TIC.TicIn.FullName);
if (strcmp(RealName, TIC.TicIn.File)) {
/*
* File in inbound has not the same name as the name on disk.
* It may be a LFN but also a case difference. The whole tic
* processing is based on 8.3 filenames.
*/
snprintf(Temp, bufsize, "%s/%s", TIC.Inbound, RealName);
snprintf(Temp2, PATH_MAX, "%s/%s", TIC.Inbound, TIC.TicIn.File);
if (rename(Temp, Temp2))
WriteError("$Can't rename %s to %s", Temp, Temp2);
else
Syslog('f', "Renamed %s to %s", Temp, Temp2);
}
}
strncpy(TIC.NewFile, TIC.TicIn.File, 80);
strncpy(TIC.NewFullName, TIC.TicIn.FullName, 255);
free(Temp2);
free(Temp);
free(Buf);
tic_in++;
rc = ProcessTic(&sbl, opl);
tidy_falist(&sbl);
return rc;
}
String *
Swig_name_mangle(const String_or_char *s) {
String *r = NewString(s);
name_mangle(r);
return r;
}
