void main(int argc, char**argv) { int ch,i,j; FILE *fp1; char *pathname; char hexnum[] = { " " }; char hexdata[] = { "[ 0 1 2 3 4 5 6 7 8 9 A B C D E F]" }; char chardata[] = { "[0123456789ABCDEF]" }; if(MAXINTx2 < 2*sizeof(int)) { printf("MAXINTx2 is not large enough!"); exit(1); } if(argc>2) { printf("Too many parameters!\n"); exit(1); } else if(argc==2) pathname = argv[1]; else { pathname = calloc(MAXPATH, sizeof(char)); printf("Input filename: "); gets(pathname); } printf("File: %s\n",pathname); if( *pathname == '\0' ) { printf("You did not give a file name!\n"); exit(1); } fp1 = fopen(pathname, "r"); if (fp1 == NULL) { printf("cannot open %s\n", pathname); exit(1); } printf(" %s %s %s\n\n",hexnum,hexdata,chardata); for (i=0; ( (ch=fgetc(fp1)) != EOF) ; i++) { byte2hex(ch,&hexdata[3*(i%16)+1]); chardata[i%16+1] = pablechar(ch); if ( (i%16)==15 ) printf(" %s %s %s\n",int2hex((i/16)*16,hexnum),hexdata,chardata); } if( ((i-1)%16)!=15 ) { for(j=(i%16);j<16;j++) { chardata[ j+1] = ' '; hexdata[3*j+1] = ' '; hexdata[3*j+2] = ' '; } printf(" %s %s %s\n",int2hex((i/16)*16,hexnum),hexdata,chardata); } fclose(fp1); exit(0); }
bool asn_sequence::writeAll(std::ostream& ostr){ if(writeable){ ostr<<int2hex(tag)<<int2hex(getSize()); for (std::vector<asn_object*>::iterator it = elements.begin() ; it != elements.end(); ++it){ (*it)->writeAll(ostr); } return true; } else return 0; }
int pack_hex(char* src, ut64 len, char* dst) { int i = 0; int x = 0; while (i < (len*2)) { int val = (src[x] & 0xf0) >> 4; dst[i++] = int2hex (val); dst[i++] = int2hex (src[x++] & 0x0f); } dst[i] = '\0'; return (len/2); }
string AmSession::getNewId() { struct timeval t; gettimeofday(&t,NULL); string id = ""; id += int2hex(get_random()) + "-"; id += int2hex(t.tv_sec) + int2hex(t.tv_usec) + "-"; id += int2hex((unsigned int)((unsigned long)pthread_self())); return id; }
main() { int c; c = 0; while ((c = getchar()) != EOF) { if ( c > 31 && c < 127 ) { putchar(c); } else { putchar('^'); putchar('^'); putchar( int2hex( c / 16 ) ); putchar( int2hex( c % 16 ) ); } } return 0; }
int main(int argc, char *argv[]) { int convert = 1194684; char *result; result = int2hex(convert); printf("Integer to hex string: %s\n", result); }
void HIDDevice::SetReport(const uint8_t* buffer, int bytes, int report_size, uint8_t report_id) { log_str("-- SetRep "); for (int c = 0; c < bytes; ++c) log_str(int2hex(buffer[c]) + " "); log_str("\n"); // alloc and clear the buffer int buff_size = report_size + 1; char sendbuff[buff_size]; memset(sendbuff, 0, buff_size); // set the report ID and the data sendbuff[0] = report_id; memcpy(sendbuff + 1, buffer, bytes); int result = usbhidSetReport(hHIDDev, sendbuff, buff_size); if (result != USBOPEN_SUCCESS) { log_str("Unable to send data to programmer.\n"); throw std::string("Unable to send data to programmer."); } log_str("-- out of SetRep\n"); }
int gps_write_command(gps_t *g, const char *cmd) { int chk = gps_compute_checksum((uint8_t*) cmd); uint8_t cmdchk[5]; cmdchk[0] = int2hex(chk>>4); cmdchk[1] = int2hex(chk&0x0f); cmdchk[2] = '\r'; cmdchk[3] = '\n'; write_fully(g->fd, cmd, strlen((char*) cmd)); write_fully(g->fd, cmdchk, 4); return 0; }
void HIDDevice::GetReport(uint8_t* buffer, int report_size, uint8_t report_id) { log_str("-- into GetRep\n"); int buff_size = report_size + 1; char rcvBuff[buff_size]; int res = usbhidGetReport(hHIDDev, report_id, rcvBuff, &buff_size); if (res != USBOPEN_SUCCESS) { log_str("Unable to read data from programmer.\n"); throw std::string("Unable to read data from programmer"); } memcpy(buffer, rcvBuff + 1, report_size); log_str("-- GetRep "); for (int c = 0; c < report_size; ++c) log_str(int2hex(buffer[c]) + " "); log_str("\n"); log_str("-- out of GetRep\n"); }
char *type7_encrypt(const char *plain) { unsigned int key, i, plen = strlen(plain); char *hash = malloc(plen * 2 + 3); if (plen > 25) plen = 25; key = rand() % 16; hash[0] = key > 9 ? '1' : '0'; hash[1] = key % 10 + '0'; for (i = 2; i <= plen * 2; ++i) { char c = plain[i / 2 - 1] ^ xlat[key++]; hash[i] = int2hex(c >> 4); hash[++i] = int2hex(c & 15); } hash[i] = 0; return hash; }
int trans_layer::send_request(sip_msg* msg, char* tid, unsigned int& tid_len) { // Request-URI // To // From // Call-ID // CSeq // Max-Forwards // Via // Contact // Supported / Require // Content-Length / Content-Type assert(transport); tid_len = 0; if(set_next_hop(msg->route,msg->u.request->ruri_str, &msg->remote_ip) < 0){ // TODO: error handling DBG("set_next_hop failed\n"); //delete msg; return -1; } // assume that msg->route headers are not in msg->hdrs msg->hdrs.insert(msg->hdrs.begin(),msg->route.begin(),msg->route.end()); int request_len = request_line_len(msg->u.request->method_str, msg->u.request->ruri_str); char branch_buf[BRANCH_BUF_LEN]; compute_branch(branch_buf,msg->callid->value,msg->cseq->value); cstring branch(branch_buf,BRANCH_BUF_LEN); string via(transport->get_local_ip()); if(transport->get_local_port() != 5060) via += ":" + int2str(transport->get_local_port()); request_len += via_len(stl2cstr(via),branch); request_len += copy_hdrs_len(msg->hdrs); string content_len = int2str(msg->body.len); request_len += content_length_len(stl2cstr(content_len)); request_len += 2/* CRLF end-of-headers*/; if(msg->body.len){ request_len += msg->body.len; } // Allocate new message sip_msg* p_msg = new sip_msg(); p_msg->buf = new char[request_len]; p_msg->len = request_len; // generate it char* c = p_msg->buf; request_line_wr(&c,msg->u.request->method_str, msg->u.request->ruri_str); via_wr(&c,stl2cstr(via),branch); copy_hdrs_wr(&c,msg->hdrs); content_length_wr(&c,stl2cstr(content_len)); *c++ = CR; *c++ = LF; if(msg->body.len){ memcpy(c,msg->body.s,msg->body.len); // Not needed by now as the message is finished //c += body.len; } // and parse it if(parse_sip_msg(p_msg)){ ERROR("Parser failed on generated request\n"); ERROR("Message was: <%.*s>\n",p_msg->len,p_msg->buf); delete p_msg; return MALFORMED_SIP_MSG; } memcpy(&p_msg->remote_ip,&msg->remote_ip,sizeof(sockaddr_storage)); DBG("Sending to %s:%i <%.*s>\n", get_addr_str(((sockaddr_in*)&p_msg->remote_ip)->sin_addr).c_str(), ntohs(((sockaddr_in*)&p_msg->remote_ip)->sin_port), p_msg->len,p_msg->buf); trans_bucket* bucket = get_trans_bucket(p_msg->callid->value, get_cseq(p_msg)->num_str); bucket->lock(); int send_err = transport->send(&p_msg->remote_ip,p_msg->buf,p_msg->len); if(send_err < 0){ ERROR("Error from transport layer\n"); delete p_msg; } else { sip_trans* t = bucket->add_trans(p_msg,TT_UAC); if(p_msg->u.request->method == sip_request::INVITE){ // if transport == UDP t->reset_timer(STIMER_A,A_TIMER,bucket->get_id()); // for any transport type t->reset_timer(STIMER_B,B_TIMER,bucket->get_id()); } else { // if transport == UDP t->reset_timer(STIMER_E,E_TIMER,bucket->get_id()); // for any transport type t->reset_timer(STIMER_F,F_TIMER,bucket->get_id()); } string t_id = int2hex(bucket->get_id()).substr(5,string::npos) + ":" + long2hex((unsigned long)t); memcpy(tid,t_id.c_str(),t_id.length()); tid_len = t_id.length(); } bucket->unlock(); return send_err; }
/* send a message to the serial port. This will add the necessary * header. */ static void qemud_serial_send( QemudSerial* s, int channel, ABool framing, const uint8_t* msg, int msglen ) { uint8_t header[HEADER_SIZE]; uint8_t frame[FRAME_HEADER_SIZE]; int avail, len = msglen; if (msglen <= 0 || channel < 0) return; D("%s: channel=%2d len=%3d '%s'", __FUNCTION__, channel, msglen, quote_bytes((const void*)msg, msglen)); if (framing) { len += FRAME_HEADER_SIZE; } /* packetize the payload for the serial MTU */ while (len > 0) { avail = len; if (avail > MAX_SERIAL_PAYLOAD) avail = MAX_SERIAL_PAYLOAD; /* write this packet's header */ #if SUPPORT_LEGACY_QEMUD if (s->version == QEMUD_VERSION_LEGACY) { int2hex(header + LEGACY_LENGTH_OFFSET, LENGTH_SIZE, avail); int2hex(header + LEGACY_CHANNEL_OFFSET, CHANNEL_SIZE, channel); } else { int2hex(header + LENGTH_OFFSET, LENGTH_SIZE, avail); int2hex(header + CHANNEL_OFFSET, CHANNEL_SIZE, channel); } #else int2hex(header + LENGTH_OFFSET, LENGTH_SIZE, avail); int2hex(header + CHANNEL_OFFSET, CHANNEL_SIZE, channel); #endif T("%s: '%.*s'", __FUNCTION__, HEADER_SIZE, header); qemu_chr_write(s->cs, header, HEADER_SIZE); /* insert frame header when needed */ if (framing) { int2hex(frame, FRAME_HEADER_SIZE, msglen); T("%s: '%.*s'", __FUNCTION__, FRAME_HEADER_SIZE, frame); qemu_chr_write(s->cs, frame, FRAME_HEADER_SIZE); avail -= FRAME_HEADER_SIZE; len -= FRAME_HEADER_SIZE; framing = 0; } /* write message content */ T("%s: '%.*s'", __FUNCTION__, avail, msg); qemu_chr_write(s->cs, msg, avail); msg += avail; len -= avail; } }
void sync_server::send() { int packet_size; int ssize; int ss; while(true) { std::unique_lock<std::mutex> lck(sending_mutex); if(send_queue.empty()) { sending_cv.wait(lck); } else { /*********************************************************************/ send_packet = send_queue.top(); //取最高优先级的队列元素。。。。。。 send_queue.pop(); //取出元素后,删除队列头的元素。。。。。。 /*********************************************************************/ int data_len = ntohl(send_packet.head_union.head.total_length) - UDT_PACKET_HEAD_LEN; //LOG(INFO)<<"data_len is:"<<data_len<<"........................."; memset(send_buf, 0, sizeof(send_buf)); //copy head info into send_buf........... memcpy(send_buf, &send_packet, sizeof(UDT_PACKET_HEAD_STRUCT)); //sending head info packet_size = sizeof(UDT_PACKET_HEAD_STRUCT); ssize = 0; while (ssize < packet_size) { if (UDT::ERROR == (ss = UDT::send(recver, send_buf + ssize, packet_size - ssize, 0))) { LOG(INFO) << "send:" << UDT::getlasterror().getErrorMessage() << endl; break; } ssize += ss; } if(ssize == packet_size) { LOG(INFO)<<"cmd = "<<int2hex(ntohl(send_packet.head_union.head.cmd))<<"; send head successful......"; } else { LOG(ERROR)<<"send function error......"; is_connected = false; break; } usleep(100); if (data_len != 0) { //copy data into send_buf................ memcpy(send_buf + sizeof(UDT_PACKET_HEAD_STRUCT), send_packet.p_data, data_len); //int bytes_sent1 = ::sendto(main_socket.socket_fd, send_buf + sizeof(NET_PACKET_HEAD_STRUCT), data_len, 0,(struct sockaddr*)&main_sockaddr_UDP,sizeof(main_sockaddr_UDP)); //sending data info packet_size = data_len; ssize = 0; while (ssize < packet_size) { if (UDT::ERROR == (ss = UDT::send(recver, send_buf + sizeof(UDT_PACKET_HEAD_STRUCT) + ssize, packet_size - ssize, 0))) { LOG(INFO) << "send:" << UDT::getlasterror().getErrorMessage() << endl; break; } ssize += ss; } //LOG(INFO) << "After ::send(...) function......"; //LOG(INFO)<<"data_len is "<<data_len; if(ssize == packet_size) { LOG(INFO)<<"cmd = "<<int2hex(ntohl(send_packet.head_union.head.cmd))<<"; send data successful......"; delete[] send_packet.p_data; } else { LOG(ERROR)<<"send function error......"; is_connected = false; break; } } } } }
void sync_server::receive() { int packet_size; int rsize; int rs; while(true) { memset(recv_buf, 0, BUFF_SIZE); //receiving head info rsize = 0; packet_size = UDT_PACKET_HEAD_LEN; while (rsize < packet_size) { try { if (UDT::ERROR == (rs = UDT::recv(recver, recv_buf + rsize, packet_size - rsize, 0))) { LOG(INFO) << "recv:" << UDT::getlasterror().getErrorMessage(); break; } } catch(...) { LOG(INFO)<<"Something was wrong in recv......"; } rsize += rs; } //加锁, 开始保护结构体变量recv_packet std::unique_lock<std::mutex> lck(cmd_finished_mtx); if(rsize == packet_size) { memset(&recv_packet.head_union.head, 0, sizeof(recv_packet.head_union.head)); memcpy(&recv_packet.head_union.head, recv_buf, sizeof(recv_packet.head_union.head)); LOG(INFO)<<"cmd = "<<int2hex(ntohl(recv_packet.head_union.head.cmd))<<"; receive successful (head)......"; } else { LOG(ERROR)<<"recv() fuction error (receiving head)......"; break; } recv_packet.head_union.head.cmd = ntohl(recv_packet.head_union.head.cmd); recv_packet.head_union.head.total_length = ntohl(recv_packet.head_union.head.total_length); recv_packet.head_union.head.cnt = ntohl(recv_packet.head_union.head.cnt); recv_packet.head_union.head.check = ntohl(recv_packet.head_union.head.check); recv_packet.head_union.head.priority = ntohl(recv_packet.head_union.head.priority); recv_packet.head_union.head.status = ntohl(recv_packet.head_union.head.status); //receive data int data_len = recv_packet.head_union.head.total_length - UDT_PACKET_HEAD_LEN; if(data_len == 0) { recv_packet.p_data = NULL; } else if(data_len >0) { memset(recv_buf, 0, BUFF_SIZE); //LOG(INFO)<<"Before ::recv(data)....."; //receiving data... rsize = 0; packet_size = data_len; while (rsize < packet_size) { //int rcv_size; //int var_size = sizeof(int); //UDT::getsockopt(recver, 0, UDT_RCVDATA, &rcv_size, &var_size); if (UDT::ERROR == (rs = UDT::recv(recver, recv_buf + rsize, packet_size - rsize, 0))) { LOG(INFO) << "recv:" << UDT::getlasterror().getErrorMessage(); break; } //LOG(INFO) << "received size for this time is : "<< rs; rsize += rs; } if(rsize == packet_size) { recv_packet.p_data = new char[data_len]; memcpy(recv_packet.p_data, recv_buf, data_len); } else { LOG(ERROR)<<"recv() fuction error (receiving data)......"; break; } } //释放互斥锁cmd_finished_mutex //LOG(INFO) << "Before pthread_mutex_unlock ...... "; //pthread_mutex_unlock(&cmd_finished_mutex); //LOG(INFO) << "After pthread_mutex_unlock ...... "; /*********************此段文字有待于进一步斟酌******************************************* 为了确保pthread_cond_timewait(...)函数先于pthread_cond_broadcast(...)函数执行 此处如果用互斥锁或者是在单元函数中为pthread_cond_timewait(...)函数单独开辟线程,则程序变得非常复杂,不容易被理解。 同时,也不能从根本上解决问题。比如,如果是为pthread_cond_timewait(...)函数单独开辟线程,并将开辟线程代码放在 package_post(...)函数之前,会有如下问题: 1. 互斥锁或许还是先被receive线程锁住,等receive线程释放锁之后 2. 若在线程开辟后再加入延迟,以确保互斥锁后被receive线程锁住,则不如直接在receive的parse中加入延迟后进行广播, 来的容易理解和方便。 ***************************************************************************************/ usleep(10000); //delay 10ms to ensure entering timewait... before broadcasting....... //网络上接收的数据已经准备好,保存在结构体变量recv_packet中,此处发出广播 //LOG(INFO) << "Before pthread_cond_broadcast ...... "; //pthread_cond_broadcast(&gVar::cmd_finished_cond); //pthread_cond_broadcast(gVar::cmd_finished_cond_QMap[recv_packet.head_union.head.cmd]); //LOG(INFO) << "After pthread_cond_broadcast ...... "; //(*cmd_finished_cond_map[recv_packet.head_union.head.cmd]).notify_one(); parse(recv_packet); } }
void trans_layer::received_msg(sip_msg* msg) { #define DROP_MSG \ delete msg;\ return int err = parse_sip_msg(msg); DBG("parse_sip_msg returned %i\n",err); if(err){ DBG("Message was: \"%.*s\"\n",msg->len,msg->buf); DBG("dropping message\n"); DROP_MSG; } assert(msg->callid && get_cseq(msg)); if(!msg->callid || !get_cseq(msg)){ DBG("Call-ID or CSeq header missing: dropping message\n"); DROP_MSG; } unsigned int h = hash(msg->callid->value, get_cseq(msg)->num_str); trans_bucket* bucket = get_trans_bucket(h); sip_trans* t = NULL; bucket->lock(); switch(msg->type){ case SIP_REQUEST: if((t = bucket->match_request(msg)) != NULL){ if(msg->u.request->method != t->msg->u.request->method){ // ACK matched INVITE transaction DBG("ACK matched INVITE transaction\n"); err = update_uas_request(bucket,t,msg); if(err<0){ DBG("trans_layer::update_uas_trans() failed!\n"); // Anyway, there is nothing we can do... } else if(err == TS_TERMINATED){ // do not touch the transaction anymore: // it could have been deleted !!! // should we forward the ACK to SEMS-App upstream? Yes } } else { DBG("Found retransmission\n"); retransmit(t); } } else { string t_id; sip_trans* t = NULL; if(msg->u.request->method != sip_request::ACK){ // New transaction t = bucket->add_trans(msg, TT_UAS); t_id = int2hex(h).substr(5,string::npos) + ":" + long2hex((unsigned long)t); } bucket->unlock(); // let's pass the request to // the UA. assert(ua); ua->handle_sip_request(t_id.c_str(),msg); if(!t){ DROP_MSG; } //Else: // forget the msg: it will be // owned by the new transaction return; } break; case SIP_REPLY: if((t = bucket->match_reply(msg)) != NULL){ // Reply matched UAC transaction DBG("Reply matched an existing transaction\n"); if(update_uac_trans(bucket,t,msg) < 0){ ERROR("update_uac_trans() failed, so what happens now???\n"); break; } // do not touch the transaction anymore: // it could have been deleted !!! } else { DBG("Reply did NOT match any existing transaction...\n"); DBG("reply code = %i\n",msg->u.reply->code); if( (msg->u.reply->code >= 200) && (msg->u.reply->code < 300) ) { bucket->unlock(); // pass to UA assert(ua); ua->handle_sip_reply(msg); DROP_MSG; } } break; default: ERROR("Got unknown message type: Bug?\n"); break; } // unlock_drop: bucket->unlock(); DROP_MSG; }
char *calStr(char *str, char type) { if (type == 's') { if (str[0] == '"') { char *newStr; myMalloc((void **)(&newStr), strlen(str) - 1); str[strlen(str) - 1] = '\0'; strcpy(newStr, str + 1); free(str); return newStr; } return str; } else if (type == 'p') { char *calInt, *p, *q; int result = 0; myMalloc((void **) (&calInt), strlen(str) + 1); for (p = calInt, q = str; *q != '\0'; q++) if (*q != 'p' && *q != 'x') { *p = *q; p++; } *p = '\0'; free(str); //纯整数计算 result = calc(calInt); free(calInt); //返回%d+"px" int i = 0, tmp = result; while (tmp) { i++; tmp /= 10; } myMalloc((void **) (&calInt), (i + 3) * sizeof(char)); sprintf(calInt, "%d", result); strcat(calInt, "px"); return calInt; } else if (type == 'c') { //计算颜色 char *calColor, *p, *q; char tmp[7], *result, *color; tmp[6] = '\0'; myMalloc((void **) (&calColor), strlen(str) + 1); memset(calColor, '\0', strlen(str) + 1); for (p = calColor, q = str; *q != '\0'; p++, q++) { if (*q == '#') { if (isdigit(q[4])) { strncpy(tmp, q + 1, 6); q += 6; } else { memset(tmp, q[1], 6); q += 3; } char *ch = hex2int(tmp); strcat(calColor, ch); p += strlen(ch) - 1; free(ch); } else *p = *q; } color = int2hex(calc(calColor)); myMalloc((void **) (&result), strlen(color) + 2); result[0] = '#'; result[1] = '\0'; strcat(result, color); free(color); free(calColor); return result; } else return str; }
static inline void log_trace(char *str, size_t len, size_t max_size, int print_stack) { int w; static __thread int in_trace = 0; /* prevent deadlock, because inital backtrace call might involve some allocs */ if(!in_trace) { #ifdef HAVE_UNWIND int unwind = 0; unw_context_t uc; unw_cursor_t cursor; int unwind_count = 0; if(print_stack) { unwind = (unw_getcontext(&uc) == 0); if(unwind) unwind = (unw_init_local(&cursor, &uc) == 0); } #else #ifdef HAVE_BACKTRACE int nptrs = 0; void *buffer[LOG_MALLOC_BACKTRACE_COUNT + 1]; in_trace = 1; /* backtrace may allocate memory !*/ if(print_stack) nptrs = backtrace(buffer, LOG_MALLOC_BACKTRACE_COUNT); #endif #endif if(g_ctx.statm_fd != -1 && (max_size - len) > 2) { str[len - 1] = ' '; /* remove NL char */ str[len] = '#'; len += pread(g_ctx.statm_fd, str + len + 1, max_size - len - 1, 0); str[len++] = '\n'; /* add NL back */ } #ifdef HAVE_UNWIND while(print_stack && unwind && unwind_count < LOG_MALLOC_BACKTRACE_COUNT && unw_step(&cursor) > 0 && max_size - len > (16 + 5)) { unw_word_t ip = 0; unw_word_t offp = 0; size_t len_start = len; unw_get_reg(&cursor, UNW_REG_IP, &ip); #ifdef HAVE_UNWIND_DETAIL /* this harms performance */ str[len++] = '*'; str[len++] = '('; if(unw_get_proc_name(&cursor, &str[len], max_size - len - 1, &offp) == 0) { len += strnlen(&str[len], max_size - len - 1); len += snprintf(&str[len], max_size - len - 1, "+0x%lx", offp); str[len++] = ')'; } else len += -2; #endif str[len++] = '['; str[len++] = '0'; str[len++] = 'x'; len += int2hex(ip, &str[len], max_size - len - 1); // max 16 chars str[len++] = ']'; str[len++] = '\n'; unwind_count++; } #else #if defined(HAVE_BACKTRACE) && defined(HAVE_BACKTRACE_SYMBOLS_FD) /* try synced write */ if(nptrs && print_stack && LOCK(g_ctx.loglock)) { w = write(g_ctx.memlog_fd, str, len); backtrace_symbols_fd(&buffer[1], nptrs, g_ctx.memlog_fd); in_trace = UNLOCK(g_ctx.loglock); /* failed unlock will not re-enable synced tracing */ } else #endif #endif { w = write(g_ctx.memlog_fd, str, len); in_trace = 0; } } else { str[len - 1] = '!'; str[len++] = '\n'; /* there is alway one char left, with '\0' from sprintf */ w = write(g_ctx.memlog_fd, str, len); } return; }