mail_p~1.cpp

一百个病毒的源代码 包括熊猫烧香等 极其具有研究价值

/////////////////////////////////////////////////////////////////////////
//This function will insert a line in a file, OR it can delete lines
//   message_line is a string to insert into the file, or can be NULL
//      if no line to write
//   file_pointer write is where to start writing the message at
//   file_pointer read is where to start reading lines from to append
//      after message_line has been written
//   if no line is to be deleted, file_pointer_read should equal 
//      file_pointer_write
//   file_pointer_write should not be greater than file_pointer_read
//      otherwise we would be writing into our data to read and would
//      be in a paradox, inserting characters that we will reinsert in an
//      endless loop

int insert_line_in_file(FILE* user_file,
			char* message_line,
			long int file_ptr_read,
			long int file_ptr_write)
{
   void* buff[3];
   size_t buff_size[2];
   size_t size=0;

   long int file_ptr_end=0;
   int fdes=-1;

   ssize_t min_size=0;
   size_t remaining_size=0;

   buff[0]=NULL;
   buff[1]=NULL;
   buff[2]=NULL;
   buff_size[0]=0;
   buff_size[1]=0;

					//we cannot write into what we're
					//   reading
   if(user_file == NULL)
   {
      syslog(LOG_MAIL | LOG_ERR,"insert_line passed NULL pointer");
      return(-1);
   }

   if(file_ptr_write > file_ptr_read)
   {
      syslog(LOG_MAIL | LOG_ERR,"insert line in file error, bad pointers");
      return(-1);
   }


   min_size=file_ptr_write;

   if(message_line != NULL)
      min_size+=strlen(message_line);

   if(min_size > file_ptr_read)
      min_size-=file_ptr_read;
   else
      min_size=0;

   if( fseek(user_file,0,SEEK_END) != 0)
   {
      syslog(LOG_MAIL | LOG_ERR,"fseek failed (%s)",strerror(errno));
      return(-1);
   }

   if( (file_ptr_end=ftell(user_file)) == -1)
   {
      syslog(LOG_MAIL | LOG_ERR,"ftell failed (%s)",strerror(errno));
      return(-1);
   }

   if(file_ptr_end < file_ptr_read)
   {
      syslog(LOG_MAIL | LOG_ERR,"invalid file pointers");
      return(-1);
   }

   remaining_size=file_ptr_end-file_ptr_read;


// min_size and remaining_size have been computed. If necessary, allocate
//    buffers


// if no remaining size, no need to allocate buffers and read data. Just
//    write new data and exit

   if(remaining_size == 0)
   {
      if( (fseek(user_file,file_ptr_write,SEEK_SET)) != 0)
      {
         syslog(LOG_MAIL | LOG_ERR,"fseek failed (%s)",strerror(errno));
         return(-1);
      }

      if(message_line != NULL)
         if( (fprintf(user_file,"%s",message_line)) < 0)
         {
            syslog(LOG_MAIL | LOG_ERR,"file write error (%s)",strerror(errno));
            return(-1);
         }

      if( (file_ptr_end=ftell(user_file)) == -1)
      {
         syslog(LOG_MAIL | LOG_ERR,"ftell failed (%s)",strerror(errno));
         return(-1);
      }

      if( (fdes=fileno(user_file)) == -1)
      {
         syslog(LOG_MAIL | LOG_ERR,"fileno failed (%s)",strerror(errno));
         return(-1);
      }

      if( ftruncate(fdes,file_ptr_end) != 0)
      {
         syslog(LOG_MAIL | LOG_ERR,"ftruncate failed (%s)",strerror(errno));
         return(-1);
      }
      
      return(0);
   }


//allocate mem

   if( (buffer_allocate(min_size, remaining_size, &size, buff)) != 0)
   {
      syslog(LOG_MAIL | LOG_ERR,"buffer allocation failed");
      return(-1);
   }




// read first buff

   if(fseek(user_file,file_ptr_read,SEEK_SET) != 0)
   {
      syslog(LOG_MAIL | LOG_ERR,"fseek failed (%s)",strerror(errno));
      free_buffers(buff);
      return(-1);
   }

   buff_size[0]=fread(buff[0], (size_t) 1, size , user_file);

   if(buff_size[0] < size && feof(user_file) == 0)
   {
      syslog(LOG_MAIL | LOG_ERR,"fread error (%s)",strerror(errno));
      free_buffers(buff);
      return(-1);
   }

   if( (file_ptr_read=ftell(user_file)) == -1)
   {
      syslog(LOG_MAIL | LOG_ERR,"ftell failed (%s)",strerror(errno));
      free_buffers(buff);
      return(-1);
   }

// point to write

   if( fseek(user_file,file_ptr_write,SEEK_SET) != 0)
   {
      syslog(LOG_MAIL | LOG_ERR,"fseek failed (%s)",strerror(errno));
      free_buffers(buff);
      return(-1);
   }


// write message if applicable

   if(message_line != NULL)
   {
      if( fprintf(user_file,"%s",message_line) < 0)
      {
         syslog(LOG_MAIL | LOG_ERR,"insert line in file failed (%s)",
				strerror(errno));
         free_buffers(buff);
         return(-1);
      }

      if( (file_ptr_write=ftell(user_file)) == -1)
      {
         syslog(LOG_MAIL | LOG_ERR,"ftell failed (%s)",strerror(errno));
         free_buffers(buff);
         return(-1);
      }
   }




// start moving data blocks

   while(buff_size[0] > 0)
   {

// read next block if not finished

      if(buff_size[0] == size)
      {
         if( fseek(user_file,file_ptr_read,SEEK_SET) != 0)
         {
            syslog(LOG_MAIL | LOG_ERR,"fseek failed (%s). "
		"Possible file corruption",strerror(errno));
            free_buffers(buff);
            return(-1);
         }

         buff_size[1]=fread(buff[1], (size_t) 1, size, user_file);

         if(buff_size[1] < size && feof(user_file) == 0)
         {
            syslog(LOG_MAIL | LOG_ERR,"fread failed (%s). "
		"Possible file corruption",strerror(errno));
            free_buffers(buff);
            return(-1);
         }
         else if(buff_size[1] == size)
         {
            if( (file_ptr_read=ftell(user_file)) == -1)
            {
               syslog(LOG_MAIL | LOG_ERR,"ftell failed (%s). "
			"Possible file corruption.",strerror(errno));
               free_buffers(buff);
               return(-1);
            }
         }
      }
      else
         buff_size[1]=0;

// write old buff

      if( fseek(user_file,file_ptr_write,SEEK_SET) == -1)
      {
         syslog(LOG_MAIL | LOG_ERR,"fseek failed (%s)",strerror(errno));
         free_buffers(buff);
         return(-1);
      }

      if( fwrite(buff[0], (size_t) 1, buff_size[0], user_file) 
		< buff_size[0])
      {
         syslog(LOG_MAIL | LOG_ERR,"fwrite failed (%s). "
			"Possible file corruption.",strerror(errno));
         free_buffers(buff);
         return(-1);
      }
      
      if( (file_ptr_write=ftell(user_file)) == -1)
      {
         syslog(LOG_MAIL | LOG_ERR,"ftell failed (%s). "
			"Possible file corruption.",strerror(errno));
         free_buffers(buff);
         return(-1);
      }

// exchange data blocks

      buff[2]=buff[0];
      buff[0]=buff[1];
      buff[1]=buff[2];

      buff_size[0]=buff_size[1];
   }



// done, cleanup and exit

   free_buffers(buff);
   fflush(user_file);

   if( (fdes=fileno(user_file)) == -1)
   {
      syslog(LOG_MAIL | LOG_ERR,"fileno failed (%s)."
		"Possible file corruption.",strerror(errno));
      return(-1);
   }

   if( (ftruncate(fdes,file_ptr_write)) != 0)
   {
      syslog(LOG_MAIL | LOG_ERR,"ftruncate failed (%s). "
		"Possible file corruption.",strerror(errno));
      return(-1);
   }

   return(0);
}

/////////////////////////////////////////////////////////////////////////

int free_buffers(void** buff)
{
   if(buff == NULL)
      return(-1);

   if(buff[0] != NULL)
   {
      free(buff[0]);
      buff[0]=NULL;
   }

   if(buff[1] != NULL)
   {
      free(buff[1]);
      buff[1]=NULL;
   }

   return(0);
}

/////////////////////////////////////////////////////////////////////////
// This function check to see if a file exists
//    returns 1 if file exists
//    returns 0 if file does not exist
//    returns -1 on error


int file_exists(char* filename)
{
   int err=0;
   struct stat file_status;

   if(filename == NULL)
      return(-1);

   err=stat(filename,&file_status);

   if(err == 0)
      return(1);

   if(errno == ENOENT)
      return(0);

   syslog(LOG_MAIL | LOG_ERR,"stat failed for %s (%s)",
			filename,strerror(errno));

   return(-1);
}

/////////////////////////////////////////////////////////////////////////
//This function will eliminate any linear whitespace (space, tab, quotes)
//   at the beginning or end of the string. If there are no valid
//   characters in the string, it will free the string and return
//   null, otherwise it will return the new string.
//   It is safe to pass a NULL string.

char* eliminate_lwsp(char* buff)
{
   char* start_ptr=NULL;
   char* tmp_ptr=NULL;

   if(buff == NULL)
      return(NULL);

   tmp_ptr=strrpcbrk(buff," \t\"'\x0d\x0a");

   if(tmp_ptr != NULL)
      *(tmp_ptr+1)='\0';

   tmp_ptr=strpcbrk(buff," \t\"'");

   if(tmp_ptr == NULL)
   {
      free(buff);
      return(NULL);
   }

   start_ptr=buff;

   while(*tmp_ptr != '\0')
   {
      *start_ptr=*tmp_ptr;
      start_ptr++;
      tmp_ptr++;
   }

   *start_ptr='\0';

   return(buff);
}

//////////////////////////////////////////////////////////////////