dev-cpp-users Mailing List for Dev-C++

Hi,

I'm writing a small program for which, I use fwrite to write the output to a
binary file. But I can write with it successfully, but the last member of
the structure is not written. What could be the problem ? here is a brief
snippet
of the fwrite section.

Thanks Johannes Pretorius for your last suggestion regarding seperating
filename and pathnames. Although
Johanne's code did'nt work, he gave me a brief Idea of how it could be done.
the code is given below the first snip.
Although its quite long, it meets its design consderation(Safety!).
Johannes, you may not like the malloc() i too
don't like it but it seems to be ok out there.

Thnx,

Jeethu Rao

<Snippet>

struct tea_hdr
 {
 char jte[3];
 unsigned char version;
 DWORD infile_size;
 DWORD infile_crc;
 unsigned char fname_sz;
 };

tea_hdr header;

 strncpy((char*)header.jte,"JTE",3);
 header.version = 1;
 header.infile_size = (DWORD)fil_len;
 header.infile_crc  = crc32;
 header.fname_sz =(unsigned char)strlen(filename);

 if(strlen(filename)>255)
 {
  fclose(outfile);
  Terror=err_fname_too_long;
  return Terror;
 }
 if((fwrite(&header,sizeof(header),1,outfile))!=1) //This writes everything
except fname_sz
 {
  cout<<"Error Here"<<endl;
  fclose(outfile);
  Terror=err_opt_file;
  return Terror;
 }
</Snippet>



int TEA::encipher_file(char* filename,char* outfilename,unsigned long*
password )
{
 FILE* infile;
 FILE* outfile;
 err_msgs Terror;
 if((infile  = fopen(filename,"rb"))==NULL)
 {
  Terror = err_no_input_file;
  return Terror;
 }
 fclose(infile);        // Just for a while

 if((outfile = fopen(outfilename,"wb"))==NULL)
 {
  fclose(infile);
  Terror = err_opt_file;
  return Terror;
 }

//Now that the Bad Guys are taken care of, lets Continue the Good Work

 DWORD crc32;
 long crc_len;
 long fil_len;
 int  crc_result;
 crc_result = crc32file(filename,&crc32,&crc_len);
 fil_len=flength(filename);
 if(fil_len ==-1)
  {
   fclose(outfile);
   Terror = err_no_input_file;
   return Terror;
  }
 if(crc_result==-1)
 {
  fclose(outfile);
  Terror = err_calc_crc;
  return Terror;
 }

struct tea_hdr
 {
 char jte[3];
 unsigned char version;
 DWORD infile_size;
 DWORD infile_crc;
 unsigned char fname_sz;
 };

tea_hdr header;

 strncpy((char*)header.jte,"JTE",3);
 header.version = 1;
 header.infile_size = (DWORD)fil_len;
 header.infile_crc  = crc32;
 header.fname_sz =(unsigned char)strlen(filename);

 cout<<"sizeof(header)      = "<< sizeof(header)<<endl;
 printf("header.jte         = %s3\n",header.jte);
 printf("header.version     = %i\n",header.version);
 printf("header.infile_size = %u\n",header.infile_size);
 printf("header.infile_crc  = %u\n",header.infile_crc);
 printf("header.fname_sz    = %d\n",header.fname_sz);

 if(strlen(filename)>255)
 {
  fclose(outfile);
  Terror=err_fname_too_long;
  return Terror;
 }
 if((fwrite(&header,sizeof(header),1,outfile))!=1)
 {
  cout<<"Error Here"<<endl;
  fclose(outfile);
  Terror=err_opt_file;
  return Terror;
 }

 if(fwrite(filename,strlen(filename),1,outfile)!=1)
 {
  fclose(outfile);
  Terror=err_opt_file;
  return Terror;
 }
 long infilebuf_sz = fil_len+(fil_len%8);
 char* infilebuf =(char*)malloc(infilebuf_sz);
 char  inbuf[8];
 char outbuf[8];

 if(infilebuf==NULL)
 {
  fclose(outfile);
  Terror=err_no_mem;
  return Terror;
 }

infile  = fopen(filename,"rb");
memset(infilebuf,'\0',infilebuf_sz);
 if(fread(infilebuf,fil_len,1,infile)!=1)
 {
  free(infilebuf);
  fclose(infile);
  fclose(outfile);
  Terror=err_input_file;
  return Terror;
 }
 for(int x=0;x<infilebuf_sz;x+=8) // might be <= ?
 {
  strncpy(inbuf,infilebuf+x,8);
  encipher((unsigned long*)inbuf,(unsigned long*)outbuf,password);

  if(fwrite((char*)&outbuf,8,1,outfile)!=1)
  {
   Terror=err_opt_file;
   return Terror;
  }

 }

 free(infilebuf);
 fclose(infile);
 fclose(outfile);
 return 0;
}

char* TEA::err2msg(int err)
{
 //errmsg loctemp;
 //loctemp = err;
 switch(err)
 {
  case err_ok:
  return "No Error Encountered\n";
  break;
  case err_no_input_file:
  return "Input File Does Not Exist\n";
  break;
  case err_no_output_file:
  return "Output File Already Exists\n";
  break;
  case err_opt_file:
  return "Error while writing Output File\n";
  break;
  case err_input_file:
  return "Error while reading input file\n";
  break;
  case err_calc_crc:
  return "Error while calculating CRC32\n";
  break;
  case err_fname_too_long:
  return "Error: The input filename is greater that 255 characters\n";
  break;
  case err_no_mem:
  return "Error: Not enough memory\n";
  break;
  }
}

<SNIPPET>
//The working code for seperating filenames and pathnames
BOOL getFileName(char *SourceString,char *cpFileDir, char *cpFileName)
{
    int iPos = 0;
    char *cpCutOffPoint;
    char *caSourceString = (char*)malloc(strlen(SourceString)+1);
    if(caSourceString==NULL)
    {
     return FALSE;
    }
    if(strlen(SourceString)==0)
    {
     free(caSourceString);
     return FALSE;
    }
    strcpy(caSourceString,SourceString);
    strrev(caSourceString);
    cpCutOffPoint = strchr(caSourceString,'\\');
    if(cpCutOffPoint==NULL)
    {
     strcpy(cpFileName,caSourceString);
     strrev(cpFileName);
     free(caSourceString);
     return TRUE;
    }
    strcpy(cpFileDir,cpCutOffPoint);
    strrev(cpFileDir);
    iPos = strlen(caSourceString)-strlen(cpFileDir);
    strncpy(cpFileName,caSourceString,iPos);
    cpFileName[iPos]='\0';
    strrev(cpFileName);
    free(caSourceString);
    return TRUE;
}
</SNIPPET>