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;
}
