コード例 #1
0
ファイル: inplace.c プロジェクト: coruus/temp
int svi_encfile(const char* outfn,
                const char* tagfn,
                const char* headerfn,
                const char* infn,
                const uint8_t* gkn) {
  int err = 0;
  mmfile inmf;
  err = mmfile_open(&inmf, infn, O_RDONLY);
  if (err != 0) { E(done, "mmfile_open %s", infn); }
  uint64_t outlen = svi_buflen(inmf.length);
  uint64_t numblocks = outlen / 65536;
  uint64_t taglen = numblocks * 64;

  mmfile outmf;
  err = mmfile_create(&outmf, outfn, outlen);
  if (err != 0) { E(cleanup_inmf, "mmfile_create %s", infn); }

  mmfile tagsmf;
  err = mmfile_create(&tagsmf, tagfn, taglen);
  if (err != 0) { E(cleanup_outmf, "mmfile_create %s", tagfn); }

  mmfile headermf;
  err = mmfile_create(&headermf, headerfn, 4096);
  if (err != 0) { E(cleanup_tagsmf, "mmfile_create %s", headerfn); }
  memset_s(headermf.mem, headermf.length, 0, headermf.length);

  err = svi_encrypt(outmf.mem, tagsmf.mem, headermf.mem, inmf.mem);
  if (err != 0) {
    // Something really bad happened. We can't assess what went
    // wrong, so we sanitize all of the output files.
    memset_s(outmf.mem, outmf.length, 0, outmf.length);
    memset_s(tagsmf.mem, tagsmf.length, 0, tagsmf.length);
    memset_s(headermf.mem, headermf.length, 0, headermf.length);
    E(cleanup_headermf, "svi_inplace %u", err);
  }


  uint8_t headertag[64] = {0};
  blake2b_state s;
  blake2b_init_key(&s, 64, gkn, 64);
  blake2b_update(&s, header, HEADERLEN);
  blake2b_final(&s, headertag, 64);
  // Clean up the blake2b state.
  memset_s(&s, sizeof(blake2b_state), 0, sizeof(blake2b_state));



cleanup_headermf: mmfile_close(&headermf);
cleanup_tagsmf:   mmfile_close(&tagsmf);
cleanup_outmf:    mmfile_close(&outmf);
cleanup_inmf:     mmfile_close(&inmf);
done:             return err;
}
int mmfile_amrparser_open (MMFileAMRHandle *handle, const char *filenamec)
{
  tMMFILE_AMR_HANDLE *privateData = NULL;
  int ret = 0;
  
  if (NULL == filenamec || NULL == handle) {
    debug_error ("file source is NULL\n");
    return MMFILE_AMR_PARSER_FAIL;
  }

  privateData = mmfile_malloc (sizeof(tMMFILE_AMR_HANDLE));
  if (NULL == privateData) {
    debug_error ("file source is NULL\n");
    return MMFILE_AMR_PARSER_FAIL;
  }
  
   /* Initialize the members of handle */
  _amr_init_handle(privateData);
  
  ret = mmfile_open (&privateData->hFile, filenamec, MMFILE_RDONLY);
  if(ret == MMFILE_UTIL_FAIL) {    	
    debug_error ("error: mmfile_open\n");
    goto exception;        
  }

  mmfile_seek (privateData->hFile, 0, MMFILE_SEEK_END);
  privateData->fileSize= mmfile_tell(privateData->hFile);
  mmfile_seek (privateData->hFile, 0, MMFILE_SEEK_SET);

  if(privateData->fileSize < MMFILE_AMR_MIN_HEADER_SIZE) {
    debug_error("Too small file to parse!!\n");
    goto exception;
  }

  ret = _parse_amr_header(privateData);
  if(ret == MMFILE_AMR_PARSER_FAIL) {
    debug_error("Invalid AMR header\n");
    goto exception;
  }
  
  if(privateData->amrChannelType != AMR_CHANNEL_TYPE_SINGLE) {
    debug_error("Unsupported channel mode\n"); /*Need to study AMR_Format.txt, Pg:36*/
    goto exception;
  }

#ifdef __MMFILE_TEST_MODE__ 
  debug_msg("AMR Format Type: %s\n", \
  privateData->amrFormat == AMR_FORMAT_NB? "AMR-NB":"AMR-WB");
#endif

  *handle = privateData;

  return MMFILE_AMR_PARSER_SUCCESS;
  
exception:
  if (privateData) { 
    mmfile_close (privateData->hFile);
    mmfile_free (privateData);
    *handle = NULL;
  }
  return MMFILE_AMR_PARSER_FAIL;
  
}