static int encrypt_file(void) { struct enc_param ep; ssize_t src_len; unsigned char *buf; uint32_t hdrlen; ssize_t totlen = 0; int err; int ret = -1; src_len = get_file_size(ifname); if (src_len < 0) { ERR("unable to get size of '%s'", ifname); goto out; } totlen = enc_compute_buf_len(product, version, src_len); hdrlen = enc_compute_header_len(product, version); buf = malloc(totlen); if (buf == NULL) { ERR("no memory for the buffer"); goto out; } err = read_file_to_buf(ifname, &buf[hdrlen], src_len); if (err) { ERR("unable to read from file '%s'", ofname); goto free_buf; } memset(&ep, '\0', sizeof(ep)); ep.key = (unsigned char *) crypt_key; ep.seed = seed; ep.longstate = longstate; ep.csum = buffalo_csum(src_len, &buf[hdrlen], src_len); ep.datalen = src_len; strcpy((char *) ep.magic, magic); strcpy((char *) ep.product, product); strcpy((char *) ep.version, version); err = encrypt_buf(&ep, buf, &buf[hdrlen]); if (err) { ERR("invalid input file"); goto free_buf; } err = write_buf_to_file(ofname, buf, totlen); if (err) { ERR("unable to write to file '%s'", ofname); goto free_buf; } ret = 0; free_buf: free(buf); out: return ret; }
int create_index_on(TCHAR * file_path)//建立索引的接口 命令行和图形界面通用 { char mutil_file_path[MAX_PATH]={}; WideCharToMultiByte(CP_OEMCP,NULL,file_path,-1,mutil_file_path,MAX_PATH,NULL,FALSE); MemoryIndexTree * temp_index=make_memory_index_tree_all_file(file_path,NULL); THE_NEXT_INDEX * temp_next_index=make_next_index__(temp_index); char index_file_name[MAX_PATH]={}; strcpy(index_file_name,mutil_file_path); strcat(index_file_name,INDEX_DB_NAME); char next_index_file_name[MAX_PATH]={}; strcpy(next_index_file_name,mutil_file_path); strcat(next_index_file_name,NEXT_INDEX_DB_NAME); int res=write_buf_to_file(temp_next_index->next_index__, temp_next_index->length/* 这个地方的length是字节数不是个数*/ ,next_index_file_name,"wb"); if (res<=0) { printf("二级索引写入失败\n"); }else { printf("二级索引写入成功\n"); } if (write_index_to_file(temp_index,index_file_name,"wb")>0) { printf("一级索引写入成功\n"); } return 0; }
static int decrypt_file(void) { struct enc_param ep; ssize_t src_len; unsigned char *buf = NULL; int err; int ret = -1; src_len = get_file_size(ifname); if (src_len < 0) { ERR("unable to get size of '%s'", ifname); goto out; } buf = malloc(src_len); if (buf == NULL) { ERR("no memory for the buffer"); goto out; } err = read_file_to_buf(ifname, buf, src_len); if (err) { ERR("unable to read from file '%s'", ifname); goto out; } memset(&ep, '\0', sizeof(ep)); ep.key = (unsigned char *) crypt_key; ep.longstate = longstate; err = decrypt_buf(&ep, buf, src_len); if (err) { ERR("unable to decrypt '%s'", ifname); goto out; } printf("Magic\t\t: '%s'\n", ep.magic); printf("Seed\t\t: 0x%02x\n", ep.seed); printf("Product\t\t: '%s'\n", ep.product); printf("Version\t\t: '%s'\n", ep.version); printf("Data len\t: %u\n", ep.datalen); printf("Checksum\t: 0x%08x\n", ep.csum); err = write_buf_to_file(ofname, buf, ep.datalen); if (err) { ERR("unable to write to file '%s'", ofname); goto out; } ret = 0; out: free(buf); return ret; }
void write_log_to_buf(const char *time_str, const char *log_str) { int str_len = 0; int time_str_len = 0; int log_str_len = 0; int remain_buf = 0; time_str_len = strlen(time_str); log_str_len = strlen(log_str); str_len = time_str_len + log_str_len; remain_buf = g_ds_log_buf.end - g_ds_log_buf.last; if (str_len > remain_buf || g_ds_log_buf.count >= DS_FLUSH_LOG_COUNT) { write_buf_to_file(g_ds_log_buf.log_buf); ds_log_buf_init(); } memcpy(&g_ds_log_buf.log_buf[g_ds_log_buf.last], time_str, time_str_len); g_ds_log_buf.last += time_str_len; memcpy(&g_ds_log_buf.log_buf[g_ds_log_buf.last], log_str, log_str_len); g_ds_log_buf.last += log_str_len; g_ds_log_buf.log_buf[g_ds_log_buf.last] = '\n'; g_ds_log_buf.last++; g_ds_log_buf.count++; if (g_ds_log_buf.count >= DS_FLUSH_LOG_COUNT) { write_buf_to_file(g_ds_log_buf.log_buf); ds_log_buf_init(); } assert((g_ds_log_buf.end - g_ds_log_buf.last) >= 0); }
void ds_log_print(int log_level, const char * format,...) { char log_str[DS_LOG_MAX_LEN + 1]; char time_str[DS_LOG_TIME_STR_LEN + 1]; va_list args; int len = 0; ds_get_time(time_str,sizeof(time_str)); va_start(args, format); len += vsnprintf(log_str , DS_LOG_MAX_LEN - len, format, args); va_end(args); log_str[len] = '\0'; pthread_mutex_lock(&g_file_lock); write_buf_to_file(time_str, log_str); pthread_mutex_unlock(&g_file_lock); return ; }
bool file_utils::write_vec_to_file(const char *pPath, const uint8_vec &data) { return write_buf_to_file(pPath, data.get_ptr(), data.size()); }
void main() { char tmpchr; char retval; SD_addr addr=0; //number of characters since the start of the current sentence int sentence_start=-1; unsigned short sentence_finished=0; unsigned char file_created=0; unsigned long bytes_received = 0; char *rx_read = rx_buffer3; char *rx_read_start; WORD fat16_date, fat16_time; packet_type pkt_type=UNKNOWN; init_light(); SD_init(); init_uart(); init_fat16(); // init_slow_gps(); //INTCONbits.GIEH=1; //start 'er up RCSTA1bits.CREN=1; tmpchr = get_uart_byte(); wait_for_eol(); while (1) { tmpchr = get_uart_byte(); if (tmpchr == '$') { sentence_start=0; sentence_finished=0; pkt_type=UNKNOWN; } if (tmpchr == '\n') { sentence_start=0; sentence_finished=1; pkt_type=UNKNOWN; } // light_off(); //according to the data sheet 1=SPS mode(?), 2=DGPS SBS mode, 6=Dead Reconing(?) mean the fixes are valid if (pkt_type == GGA && sentence_start == 43 && !(tmpchr == '1' || tmpchr== '2' || tmpchr=='6')) { rx_read-=43; bytes_received-=43; wait_for_eol(); continue; } // in an RMC sentence, the "A" field indicates that a fix is valid if (pkt_type == RMC && sentence_start == 18 && tmpchr != 'A') { rx_read-=18; bytes_received-=18; wait_for_eol(); continue; } // only consider $GPGGA and $GPRMC packets by the 4th byte we can figure out if we need this transmission or not // if we don't need it, just roll back the pointers/counters in the buffer and throw away the remaining bytes in this sentence if (sentence_start == 4) { if (tmpchr == 'M') { pkt_type = RMC; } else if (tmpchr == 'G') { pkt_type = GGA; } else { rx_read-=4; bytes_received-=4; wait_for_eol(); pkt_type = UNKNOWN; continue; } } *rx_read = tmpchr; rx_read++; sentence_start++; bytes_received++; // light_on(); if (bytes_received >= 512 && sentence_finished) { RCSTA1bits.CREN=0; //disable reception for now to avoid overrun errors rx_read_start = rx_read - bytes_received; // should always be the same as rx_buffer3 if (!file_created) { retval = find_date_time_from_sentence_buffer(&fat16_date, &fat16_time, rx_read_start, bytes_received); if (retval == 0) { create_file( fat16_date, fat16_time ); } else { create_file( 0x3ee7, /* july 7 2010 */ 0x2108 /*04:08:16am */ ); } file_created = 1; } //write data to the SD card write_buf_to_file((BYTE *)rx_read_start); /* if (retval != 0) goto bad; */ bytes_received-=512; if (bytes_received > 0) { // to make life easy, move the leftover parts of the buffer back to the top and continue copying data below it memcpy(rx_read_start, rx_read - bytes_received, bytes_received); } rx_read-=512; //renable reception RCSTA1bits.CREN=1; /* odds are we are going to have a fraction of a sentence if we start logging whatever comes in now, so wait for the sentence to end before going on */ wait_for_eol(); } } bad: SLOW_ERROR(); } // end main
void ds_log_flush() { pthread_mutex_lock(&g_log_buf_lock); write_buf_to_file(g_ds_log_buf.log_buf); pthread_mutex_unlock(&g_log_buf_lock); }