d_netfil.c

The source code of Doom legacy for windows

    // size initialized at file open 
    //p->size=size;
    p->fileid=fileid;
    p->next=NULL; // end of list

    filetosend++;
}

void SendRam(int node,byte *data, ULONG size,freemethode_t freemethode, char fileid)
{
    filetx_t **q,*p;

    q=&transfer[node].txlist;
    while(*q) q=&((*q)->next);
    *q=(filetx_t *)malloc(sizeof(filetx_t));
    if(!*q) 
       I_Error("SendRam : No more ram\n");
    p=*q;
    p->ram=freemethode;
    p->filename=data;
    p->size=size;
    p->fileid=fileid;
    p->next=NULL; // end of list

    DEBFILE(va("Sending ram %x( size:%d) to %d (id=%d)\n",p->filename,size,node,fileid));

    filetosend++;
}

void EndSend(int node)
{
    filetx_t *p=transfer[node].txlist;
    switch (p->ram) {
    case SF_FILE:
        if( transfer[node].currentfile )
            fclose(transfer[node].currentfile);
        free(p->filename);
        break;
    case SF_Z_RAM:
        Z_Free(p->filename);
        break;
    case SF_RAM:
        free(p->filename);
    case SF_NOFREERAM:
        break;
    }
    transfer[node].txlist = p->next;
    transfer[node].currentfile = NULL;
    free(p);                 
    filetosend--;
}

#define PACKETPERTIC net_bandwidth/(TICRATE*software_MAXPACKETLENGTH)

void FiletxTicker(void)
{
    static int currentnode=0;
    filetx_pak *p;
    ULONG      size;
    filetx_t   *f;
    int        ram,i;
    int        packetsent = PACKETPERTIC;

    if( filetosend==0 )
        return;
    if(packetsent==0) packetsent++;
    // (((sendbytes-nowsentbyte)*TICRATE)/(I_GetTime()-starttime)<(ULONG)net_bandwidth)
    while( packetsent-- && filetosend!=0)
    {
    for(i=currentnode,ram=0;ram<MAXNETNODES;i=(i+1)%MAXNETNODES,ram++)
        if(transfer[i].txlist)
            goto found;
    // no transfer to do
    I_Error("filetosend=%d but no filetosend found\n",filetosend);
found:
    currentnode=(i+1)%MAXNETNODES;
    f=transfer[i].txlist;
    ram=f->ram;

    if(!transfer[i].currentfile) // file not allready open
    {
        if(!ram) {
            long filesize;

            transfer[i].currentfile = fopen(f->filename,"rb");

            if(!transfer[i].currentfile)
                I_Error("File %s not exist", f->filename);

            fseek(transfer[i].currentfile, 0, SEEK_END);
            filesize = ftell(transfer[i].currentfile);

            // nobody wants to transfer a file bigger than 4GB!
            // and computers will never need more than 640kb of RAM ;-)
            if(-1 == filesize)
            {
                perror("Error");
                I_Error("Error getting filesize of %s\n", f->filename);
            }

            f->size = filesize;
            fseek(transfer[i].currentfile, 0, SEEK_SET);            
        }
        else
            transfer[i].currentfile = (FILE *)1;
        transfer[i].position=0;
    }

    p=&netbuffer->u.filetxpak;
    size=software_MAXPACKETLENGTH-(FILETXHEADER+BASEPACKETSIZE);
    if( f->size-transfer[i].position<size )
        size=f->size-transfer[i].position;
    if(ram)
        memcpy(p->data,&f->filename[transfer[i].position],size);
    else
    {
        if( fread(p->data,size,1,transfer[i].currentfile) != 1 )
            I_Error("FiletxTicker : can't get %d byte on %s at %d",size,f->filename,transfer[i].position);
    }
    p->position = transfer[i].position;
    // put flag so receiver know the totalsize
    if( transfer[i].position+size==f->size )
        p->position |= 0x80000000;
    p->fileid   = f->fileid;
    p->size=size;
    netbuffer->packettype=PT_FILEFRAGMENT;
    if (!HSendPacket(i,true,0,FILETXHEADER+size ) ) // reliable SEND
    { // not sent for some od reason
      // retry at next call
         if( !ram )
             fseek(transfer[i].currentfile,transfer[i].position,SEEK_SET);
         // exit the while (can't sent this one why should i sent the next ?
         break;
    }
    else // success
    {
        transfer[i].position+=size;
        if(transfer[i].position==f->size) //  finish ?
            EndSend(i);
    }
    }
}

void Got_Filetxpak(void)
{
    int filenum=netbuffer->u.filetxpak.fileid;
static int time=0;

    if(filenum>=fileneedednum)
    {
        DEBFILE(va("fileframent not needed %d>%d\n",filenum,fileneedednum));
        return;
    }

    if( fileneeded[filenum].status==FS_REQUESTED )
    {
        if(fileneeded[filenum].phandle) I_Error("Got_Filetxpak : allready open file\n");
        fileneeded[filenum].phandle=fopen(fileneeded[filenum].filename,"wb");
        if(!fileneeded[filenum].phandle) I_Error("Can't create file %s : disk full ?",fileneeded[filenum].filename);
        CONS_Printf("\r%s...",fileneeded[filenum].filename);
        fileneeded[filenum].currentsize = 0; 
        fileneeded[filenum].status=FS_DOWNLOADING;
    }

    if( fileneeded[filenum].status==FS_DOWNLOADING )
    {
        // use a special tric to know when file is finished (not allways used)
        // WARNING: filepak can arrive out of order so don't stop now !
        if( netbuffer->u.filetxpak.position & 0x80000000 ) 
        {
            netbuffer->u.filetxpak.position &= ~0x80000000;
            fileneeded[filenum].totalsize = netbuffer->u.filetxpak.position + netbuffer->u.filetxpak.size;
        }
        // we can receive packet in the wrong order, anyway all os support gaped file
        fseek(fileneeded[filenum].phandle,netbuffer->u.filetxpak.position,SEEK_SET);
        if( fwrite(netbuffer->u.filetxpak.data,netbuffer->u.filetxpak.size,1,fileneeded[filenum].phandle)!=1 )
            I_Error("Can't write %s : disk full ?\n",fileneeded[filenum].filename);
        fileneeded[filenum].currentsize+=netbuffer->u.filetxpak.size;
        if(time==0)
        {
            Net_GetNetStat();
            CONS_Printf("\r%s %dK/%dK %.1fK/s",fileneeded[filenum].filename,
                                               fileneeded[filenum].currentsize>>10,
                                               fileneeded[filenum].totalsize>>10,
                                               ((float)getbps)/1024);
        }

        // finish ?
        if(fileneeded[filenum].currentsize==fileneeded[filenum].totalsize) 
        {
            struct utimbuf utb;
            fclose(fileneeded[filenum].phandle);
            utb.actime=fileneeded[filenum].timestamp;
            utb.modtime=fileneeded[filenum].timestamp;
            utime(fileneeded[filenum].filename,&utb);
            fileneeded[filenum].phandle=NULL;
            fileneeded[filenum].status=FS_FOUND;
            CONS_Printf("\rDownloading %s...(done)\n",fileneeded[filenum].filename);
        }
    }
    else
        I_Error("Received a file not requested\n");
    // send ack back quickly

    if(++time==4)
    {
        Net_SendAcks(servernode);
        time=0;
    }

}

void AbortSendFiles(int node)
{
    while(transfer[node].txlist)
        EndSend(node);
}

void CloseNetFile(void)
{
    int i;
    // is sending ?
    for( i=0;i<MAXNETNODES;i++)
        AbortSendFiles(i);

    // receiving a file ?
    for( i=0;i<MAX_WADFILES;i++ )
        if( fileneeded[i].status==FS_DOWNLOADING && fileneeded[i].phandle)
        {
            fclose(fileneeded[i].phandle);
            // file is not compete delete it
            remove(fileneeded[i].filename);
        }

    // remove FILEFRAGMENT from acknledge list
    Net_AbortPacketType(PT_FILEFRAGMENT);
}

// functions cut and pasted from doomatic :)

void nameonly(char *s)
{
  int j;

  for(j=strlen(s);j>=0;j--)
      if( (s[j]=='\\') || (s[j]==':') || (s[j]=='/') )
      {
          memcpy(s, &(s[j+1]), strlen(&(s[j+1]))+1 );
          return;
      }
}

#if defined(LINUX) || defined(__MACOS__)
#define O_BINARY 0
#endif

// UNUXED for now
boolean fileexist(char *filename,time_t time)
{
   int handel;
   handel=open(filename,O_RDONLY|O_BINARY);
   if( handel!=-1 )
   {
         close(handel);
         if(time!=0)
         {
            struct stat bufstat;
            stat(filename,&bufstat);
            if( time!=bufstat.st_mtime )
                return false;
         }
         return true;
   }
   else
       return false;
}

//
// recsearch
//
// ATTENTION : make sure there is enouth space in filename to put a full path (255 or 512)
// if timestamp==0 there is no time check
// if changestring then filename will be change with the full path and name
// return FS_NOTFOUND
//        FS_FOUND

filestatus_t recsearch(char *filename,time_t timestamp,boolean changestring)
#ifdef __WIN32__
{
  struct _finddata_t dta;
  struct stat bufstat;
  int    searchhandle;

  searchhandle=stat(filename,&bufstat);
  if(searchhandle!=-1)
  {
      if(timestamp)
      {
          // take care of gmt timestamp conversion
          if(bufstat.st_mtime==timestamp || bufstat.st_mtime+timezoneoffset==timestamp)
              return FS_FOUND;
          //else
          //    return FS_FOUNDWRONGDATE; // found with differant date
          //  continue search
      }
      else
          return FS_FOUND;
  }

  if((searchhandle=_findfirst("*.*",&dta))!=-1)
  {
    do {
        if((dta.name[0]!='.') && (dta.attrib & _A_SUBDIR ))
        {
            if( chdir(dta.name)==0 ) { // can fail if we haven't the right
                int found;
                found = recsearch(filename,timestamp,changestring);
                chdir("..");
                if( found )
                {
                    if(changestring)
                        strcatbf(filename,dta.name,"\\");
                    _findclose(searchhandle);
                    return found;
                }
            }
        }
    } while(_findnext(searchhandle,&dta)==0);
  }
  _findclose(searchhandle);
  return FS_NOTFOUND;
}

#else
#ifdef __DJGPP__
{
  struct ffblk dta;

  if(findfirst(filename,&dta,0)==0)
  {
      if(timestamp)
      {
          struct stat statbuf;
          stat(filename,&statbuf);
          if (statbuf.st_mtime==timestamp || statbuf.st_mtime+timezoneoffset==timestamp)
              return FS_FOUND;
          //else
          //    return FS_FOUNDWRONGDATE; // found with differant date
          //  continue search

      }
      return FS_FOUND;
  }

  if(findfirst("*.*",&dta,FA_DIREC)==0)
  {
    do {
      if((dta.ff_name[0]!='.') && (dta.ff_attrib & FA_DIREC))
      {
        if( chdir(dta.ff_name)==0 ) { // can fail if we haven't the right
            int found;
            found = recsearch(filename,timestamp,changestring);
            chdir("..");
            if(found)
            {
                if( changestring )
                    strcatbf(filename,dta.ff_name,"\\");

                return found;
            }
        }
      }
    } while(findnext(&dta)==0);
  }
  return FS_NOTFOUND;
}
#else
#if defined( LINUX) || defined( __OS2__)
/* readdir and stat is portable 19990508 by Kin */
{
    DIR *dds;
    struct stat stb;
    struct dirent *dnt;
    int found = FS_NOTFOUND;
    if(!stat(filename,&stb)) {
      if(timestamp) {
          if(stb.st_mtime==timestamp || stb.st_mtime+timezoneoffset==timestamp)
             return FS_FOUND;
          //else
          //   return FS_FOUNDWRONGDATE;
          //  continue search
      }
       return FS_FOUND;
    }
    dds = opendir(".");
    while((dnt = readdir(dds))!=0) {
      if(dnt->d_name[0]!='.') {
        if(!stat(dnt->d_name,&stb)) {
          if(S_ISDIR(stb.st_mode)) {
            if(!chdir(dnt->d_name)) {
                   found = recsearch(filename,timestamp,changestring);
                   chdir("..");
            };
            if(found) {
              /* don't forget this! is it big enough for unix? */
              if(changestring)
                  strcatbf(filename,dnt->d_name,"/");
              return found;
            };
          }
        }
      }
    }
    closedir(dds);
    return FS_NOTFOUND;
}
#else
#ifdef __MACOS__
{
        return FS_NOTFOUND;
}
#else
#error Please implement recsearch function for this OS !
#endif
#endif
#endif
#endif