BL> Area SPECIALR
BL> Origin 3:711/934.12
BL> From 3:711/934.12
BL> File BORING.ZIP
BL> Desc An incredibly boring file
BL> Pw wallyburger

BL> Is this right? Are you *sure* there is no name in the TIC?

Having never read any docs on the issue, here is one I received from Dave...

Area ZONEDIFF
Origin 3:632/348
From 3:711/808
File Z3DIFF.L13
Desc FidoNet Zone 3 difference file for day 313 (08-Nov-1996) in LHA format
CRC 19DCFAF8
Created by TICK v2.10 (C) Copyright Barry Geller - 1988,1989,1990,1991,1992
Size 1828
Date 3646102C
Path 3:632/348 847428141 Tue Nov  8  4:42:21 1994 GMT
Path 3:711/808 847369111 Thu Nov 07 12:18:31 1996 GMT
Seenby 3:632/348
Seenby 3:635/503
Seenby 3:711/808
Seenby 3:640/820
Seenby 3:632/522
Seenby 3:690/613
Seenby 3:690/442
Seenby 8:7877/2809
Seenby 3:800/1
Seenby 3:770/101
Seenby 3:711/899
Seenby 3:714/906
Seenby 3:711/932
Seenby 3:711/934
Seenby 3:713/317
Seenby 3:711/401
Seenby 3:711/410
Seenby 3:711/413
Seenby 3:711/430
Seenby 3:625/160
Seenby 3:623/630
Seenby 3:621/505
Seenby 3:620/243
Seenby 3:50/99
Seenby 3:711/409
Pw wollyburger


BL> It would make more sense if the Origin field was the fido number and
BL> the From field was "Bob Lawrence".

No-one actually cares what alias you happen to use on your system.

BL> As it stands, I can identify the sender by the point number or the
BL> whole fido address, but what happens if you want to give access to
BL> someone who is not one of your points?

I use their address.  No problem.

BL> ... [later still...]

BL> I'd like to send a message back to the sendee. How can I do that?

BL> TIC is automatic, but there are many ways it can fail. You don't
BL> give a stuff if it works or not, so there's no point in sending you
BL> messages, but it would be nice to send back a report to the sendee,

That's a good idea.  At the moment, yatic writes to a log file, but I only
look at that when I decide to clean up my inbound directory.

If you write a .PKT file containing a netmail from my system, I can easily
toss that after running TIC.  If writing a .PKT directly is too much
hassle, I wrote a utility that does that.

BL> I'm hoping it will be quick enough to do online (1 second or less).
BL> Can I just put a message in a directory and have it sent off with the
BL> mail?

You can't do it online unless you modify binkley.  I'll post the code to my
utility to create .PKTs below.  BFN.  Paul.

/*********************************************************************/
/*                                                                   */
/*  This Program Written by Paul Edwards, 3:711/934{at}fidonet.         */
/*  Released to the Public Domain                                    */
/*                                                                   */
/*********************************************************************/
/*********************************************************************/
/*                                                                   */
/*  genpmsg - generate packet message.                               */
/*                                                                   */
/*********************************************************************/

#include 
#include 

typedef struct {
    int year;
    int month;
    int day;
    int hour;
    int min;
    int sec;
} dt;

typedef struct {
    unsigned char origNode[2];
    unsigned char destNode[2];
    unsigned char origNet[2];
    unsigned char destNet[2];
    unsigned char Attribute[2];
    unsigned char cost[2];
} raw_fido_msg_hdr;

typedef struct {
    int origNode;
    int destNode;
    int origNet;
    int destNet;
    int origZone;
    int destZone;
    unsigned int Attribute;
    int cost;
} fido_msg_hdr;

typedef struct {
    unsigned char origNode[2];
    unsigned char destNode[2];
    unsigned char year[2];
    unsigned char month[2];
    unsigned char day[2];
    unsigned char hour[2];
    unsigned char minute[2];
    unsigned char second[2];
    unsigned char baud[2];
    unsigned char PacketType[2];
    unsigned char origNet[2];
    unsigned char destNet[2];
    unsigned char prodCode;
    unsigned char serialNo;
    unsigned char password[8];
    unsigned char origZone[2];
    unsigned char destZone[2];
    unsigned char auxNet[2];
    unsigned char CWvalidationCopy[2];
    unsigned char prodCodeH;
    unsigned char Revision;
    unsigned char CapabilWord[2];
    unsigned char origZone2[2];
    unsigned char destZone2[2];
    unsigned char origPoint[2];
    unsigned char destPoint[2];
    unsigned char prodData[4];
    /* zero or more packed messages, followed by "\x00\x00\x00\x00"
       follow.*/
} raw_fido_packet_hdr;

typedef struct {
    unsigned int origNode;
    unsigned int destNode;
    dt pdate;
    unsigned int baud;
    unsigned int PacketType;
    unsigned int origNet;
    unsigned int destNet;
    unsigned int prodCode;
    unsigned int serialNo;
    unsigned char password[8];
    unsigned int origZone;
    unsigned int destZone;
    unsigned int capability;
    unsigned int origPoint;
    unsigned int destPoint;
    unsigned int Revision;
    unsigned char prodData[4];
} fido_packet_hdr;

int cvt_to_raw_packet_hdr(const fido_packet_hdr *fp_hdr,
    raw_fido_packet_hdr *raw_p);

int cvt_to_raw_message_hdr(const fido_msg_hdr *fm_hdr,
    raw_fido_msg_hdr *raw_m);

int main(void)
{
    fido_packet_hdr ph;
    raw_fido_packet_hdr rph;
    fido_msg_hdr mh;
    raw_fido_msg_hdr rmh;
    FILE *fq;

    ph.origNode = 777;
    ph.destNode = 934;
    ph.pdate.year = 1994;
    ph.pdate.month = 1;
    ph.pdate.day = 1;
    ph.pdate.hour = 1;
    ph.pdate.min = 1;
    ph.pdate.sec = 1;
    ph.baud = 0;
    ph.PacketType = 2;
    ph.origNet = 711;
    ph.destNet = 711;
    ph.prodCode = 0;
    ph.serialNo = 0;
    memset(ph.password, 0x00, 8);
    ph.origZone = 3;
    ph.destZone = 3;
    ph.capability = 1;
    ph.origPoint = 8;
    ph.destPoint = 0;
    ph.Revision = 0;
    memset(ph.prodData, 0x00, 4);
    cvt_to_raw_packet_hdr(&ph, &rph);

    mh.origNode = 777;
    mh.destNode = 934;
    mh.origNet = 711;
    mh.destNet = 711;
    mh.origZone = 3;
    mh.destZone = 3;
    mh.Attribute = 0;
    mh.cost = 0;

    cvt_to_raw_message_hdr(&mh, &rmh);
    
    fq = fopen("temp.pkt", "wb");
    if (fq != NULL)
    {
        fwrite(&rph, 1, sizeof rph, fq);
        fputc(0x02, fq);
        fputc(0x00, fq);
        fwrite(&rmh, 1, sizeof rmh, fq);
        fprintf(fq, "01 Jan 94  01:01:01");
        fputc('\0', fq);
        fprintf(fq, "John Here");
        fputc('\0', fq);
        fprintf(fq, "Freddy Boswell");
        fputc('\0', fq);
        fprintf(fq, "fascist pigs");
        fputc('\0', fq);
/*        fprintf(fq, "AREA:AUST_AVTECH\r"); */
/*        fprintf(fq, "\x01" "TOPT 9\r"); */
/*        fprintf(fq, "\x01" "MSGID 1:333/444.9\r"); */
        fprintf(fq, "Hello, world!\r");
/*        fprintf(fq, "\r"); 
        fprintf(fq, "---\r");
        fprintf(fq, "SEEN-BY: 711/934\r"); */
        fputc('\0', fq);
        fputc('\0', fq);
        fputc('\0', fq);
        fclose(fq);
    }
    return (0);
}

int cvt_to_raw_message_hdr(const fido_msg_hdr *fm_hdr,
                           raw_fido_msg_hdr *raw_m)
{
    raw_m->origNode[0] = (unsigned char)(fm_hdr->origNode & 0xff);
    raw_m->origNode[1] = (unsigned char)((fm_hdr->origNode >>
8) & 0xff);
    raw_m->destNode[0] = (unsigned char)(fm_hdr->destNode & 0xff);
    raw_m->destNode[1] = (unsigned char)((fm_hdr->destNode >>
8) & 0xff);
    raw_m->origNet[0] = (unsigned char)(fm_hdr->origNet & 0xff);
    raw_m->origNet[1] = (unsigned char)((fm_hdr->origNet >> 8)
& 0xff);
    raw_m->destNet[0] = (unsigned char)(fm_hdr->destNet & 0xff);
    raw_m->destNet[1] = (unsigned char)((fm_hdr->destNet >> 8)
& 0xff);
    raw_m->Attribute[0] = (unsigned char)(fm_hdr->Attribute & 0xff);
    raw_m->Attribute[1] = (unsigned char)((fm_hdr->Attribute >>
8) & 0xff);
    raw_m->cost[0] = (unsigned char)(fm_hdr->cost & 0xff);
    raw_m->cost[1] = (unsigned char)((fm_hdr->cost >> 8) & 0xff);
    return (0);
}

int cvt_to_raw_packet_hdr(const fido_packet_hdr *fp_hdr,
    raw_fido_packet_hdr *raw_p)
{
    memset(raw_p, '\0', sizeof *raw_p);
    raw_p->origNode[0] = (unsigned char)(fp_hdr->origNode & 0xff);
    raw_p->origNode[1] = (unsigned char)((fp_hdr->origNode >>
8) & 0xff);
    raw_p->destNode[0] = (unsigned char)(fp_hdr->destNode & 0xff);
    raw_p->destNode[1] = (unsigned char)((fp_hdr->destNode >>
8) & 0xff);
    raw_p->year[0] = (unsigned char)(fp_hdr->pdate.year & 0xff);
    raw_p->year[1] = (unsigned char)((fp_hdr->pdate.year >> 8)
& 0xff);
    raw_p->month[0] = (unsigned char)(fp_hdr->pdate.month & 0xff);
    raw_p->month[1] = (unsigned char)((fp_hdr->pdate.month >>
8) & 0xff);
    raw_p->day[0] = (unsigned char)(fp_hdr->pdate.day & 0xff);
    raw_p->day[1] = (unsigned char)((fp_hdr->pdate.day >> 8) & 0xff);
    raw_p->hour[0] = (unsigned char)(fp_hdr->pdate.hour & 0xff);
    raw_p->hour[1] = (unsigned char)((fp_hdr->pdate.hour >> 8)
& 0xff);
    raw_p->minute[0] = (unsigned char)(fp_hdr->pdate.min & 0xff);
    raw_p->minute[1] = (unsigned char)((fp_hdr->pdate.min >> 8)
& 0xff);
    raw_p->second[0] = (unsigned char)(fp_hdr->pdate.sec & 0xff);
    raw_p->second[1] = (unsigned char)((fp_hdr->pdate.sec >> 8)
& 0xff);
    raw_p->baud[0] = (unsigned char)(fp_hdr->baud & 0xff);
    raw_p->baud[1] = (unsigned char)((fp_hdr->baud >> 8) & 0xff);
    raw_p->PacketType[0] = (unsigned char)(fp_hdr->PacketType & 0xff);
    raw_p->PacketType[1] = (unsigned char)((fp_hdr->PacketType
>> 8) & 0xff);
    raw_p->origNet[0] = (unsigned char)(fp_hdr->origNet & 0xff);
    raw_p->origNet[1] = (unsigned char)((fp_hdr->origNet >> 8)
& 0xff);
    raw_p->destNet[0] = (unsigned char)(fp_hdr->destNet & 0xff);
    raw_p->destNet[1] = (unsigned char)((fp_hdr->destNet >> 8)
& 0xff);
    raw_p->prodCode = (unsigned char)(fp_hdr->prodCode & 0xff);
    raw_p->serialNo = (unsigned char)(fp_hdr->serialNo & 0xff);
    memcpy(raw_p->password, fp_hdr->password, sizeof raw_p->password);
    raw_p->origZone[0] = (unsigned char)(fp_hdr->origZone & 0xff);
    raw_p->origZone[1] = (unsigned char)((fp_hdr->origZone >>
8) & 0xff);
    raw_p->destZone[0] = (unsigned char)(fp_hdr->destZone & 0xff);
    raw_p->destZone[1] = (unsigned char)((fp_hdr->destZone >>
8) & 0xff);
    raw_p->auxNet[0] = (unsigned char)raw_p->destNet[0];
    raw_p->auxNet[1] = (unsigned char)raw_p->destNet[1];
    raw_p->CWvalidationCopy[0] = (unsigned char)
         ((fp_hdr->capability >> 8) & 0xff);
    raw_p->CWvalidationCopy[1] = (unsigned char)(fp_hdr->capability
& 0xff);
    raw_p->CapabilWord[0] = raw_p->CWvalidationCopy[1];
    raw_p->CapabilWord[1] = raw_p->CWvalidationCopy[0];
    raw_p->prodCodeH = (unsigned char)((fp_hdr->prodCode >> 8)
& 0xff);
    raw_p->origZone2[0] = raw_p->origZone[0];
    raw_p->origZone2[1] = raw_p->origZone[1];
    raw_p->destZone2[0] = raw_p->destZone[0];
    raw_p->destZone2[1] = raw_p->destZone[1];
    raw_p->Revision = (unsigned char)fp_hdr->Revision;
    raw_p->origPoint[0] = (unsigned char)(fp_hdr->origPoint & 0xff);
    raw_p->origPoint[1] = (unsigned char)((fp_hdr->origPoint >>
8) & 0xff);
    raw_p->destPoint[0] = (unsigned char)(fp_hdr->destPoint & 0xff);
    raw_p->destPoint[1] = (unsigned char)((fp_hdr->destPoint >>
8) & 0xff);
    memcpy(raw_p->prodData, fp_hdr->prodData, sizeof raw_p->prodData);
    return (0);
}    
@EOT:

---