自学教程：C++ D_RETURN_函数代码示例

static int__bro_table_val_write(BroTableVal *tbl, BroConn *bc){  double d = 0;  char opt = 0;  D_ENTER;  if (! __bro_mutable_val_write((BroMutableVal *) tbl, bc))    D_RETURN_(FALSE);  if (! __bro_buf_write_double(bc->tx_buf, d))    D_RETURN_(FALSE);  /* XXX For now we neever send any attributes, nor an expire expr */  if (! __bro_buf_write_char(bc->tx_buf, opt))    D_RETURN_(FALSE);  if (! __bro_buf_write_char(bc->tx_buf, opt))    D_RETURN_(FALSE);  /* How we iterate depends on whether the index type is atomic or not.   * If atomic, we use __bro_table_val_write_cb_direct(), otherwise   * we use ..._unpack(), which converts the elements of the RecordVal   * into a ListVal before sending.   */  if (__bro_table_val_has_atomic_key(tbl))    __bro_table_foreach(tbl->table, (BroTableCallback) __bro_table_val_write_cb_direct, bc);  else    __bro_table_foreach(tbl->table, (BroTableCallback) __bro_table_val_write_cb_unpack, bc);  D_RETURN_(TRUE);}

int__bro_io_raw_queue(BroConn *bc, int type, uchar *data, int data_len){  BroMsg *msg;  int result = FALSE;    D_ENTER;  if (!bc)    D_RETURN_(FALSE);    if (! (msg = __bro_io_msg_new(type, 0)))    D_RETURN_(FALSE);  if (data_len > 0)    {            BroBuf *buf;      if (! (buf = __bro_buf_new()))	{	  __bro_io_msg_free(msg);	  D_RETURN_(FALSE);	}            __bro_buf_append(buf, data, data_len);      __bro_io_msg_set_cont(msg, BRO_MSG_CONT_RAW, buf);    }  result = io_msg_queue(bc, msg);    D_RETURN_(result);}

int      __bro_io_msg_queue_flush(BroConn *bc){  BroMsg *msg;  int result;  D_ENTER;      if (! bc)    D_RETURN_(-1);    for ( ; ; )    {      if (! io_msg_empty_tx(bc))	break;      if (! (msg = bc->msg_queue.tqh_first))	break;            if (! io_msg_fill_tx(bc, msg))	break;            TAILQ_REMOVE(&bc->msg_queue, msg, msg_queue);      __bro_io_msg_free(msg);      bc->msg_queue_len--;            bc->state->io_msg = BRO_IOMSG_WRITE;    }    result = bc->msg_queue_len;    D_RETURN_(result);}

int__bro_io_event_queue(BroConn *bc, BroEvent *ev){  BroEvent *ev_copy;  BroMsg *msg;  int result;  D_ENTER;  if (!bc)    D_RETURN_(FALSE);    if (! (msg = __bro_io_msg_new(BRO_MSG_SERIAL, 0)))    D_RETURN_(FALSE);  if (! (ev_copy = __bro_event_copy(ev)))    {      D(("Could not clone event/n"));      __bro_io_msg_free(msg);      D_RETURN_(FALSE);    }  __bro_io_msg_set_cont(msg, BRO_MSG_CONT_EVENT, ev_copy);  result = io_msg_queue(bc, msg);  D_RETURN_(result);  }

static int__bro_list_val_write(BroListVal *lv, BroConn *bc){  BroList *l;  D_ENTER;  if (! __bro_val_write((BroVal *) lv, bc))    D_RETURN_(FALSE);  if (! __bro_buf_write_char(bc->tx_buf, lv->type_tag))    D_RETURN_(FALSE);  if (! __bro_buf_write_int(bc->tx_buf, lv->len))    D_RETURN_(FALSE);  for (l = lv->list; l; l = __bro_list_next(l))    {      BroVal *val = __bro_list_data(l);      if (! __bro_sobject_serialize((BroSObject *) val, bc))	D_RETURN_(FALSE);    }  D_RETURN_(TRUE);}

static int__bro_list_val_cmp(BroListVal *lv1, BroListVal *lv2){  BroList *l1, *l2;  D_ENTER;  if (! lv1 || ! lv2)    D_RETURN_(FALSE);  if (lv1->len != lv2->len ||      lv1->type_tag != lv2->type_tag)    D_RETURN_(FALSE);  for (l1 = lv1->list, l2 = lv2->list; l1 && l2;       l1 = __bro_list_next(l1), l2 = __bro_list_next(l2))    {      if (! __bro_sobject_cmp((BroSObject*) __bro_list_data(l1),			      (BroSObject*) __bro_list_data(l2)))	D_RETURN_(FALSE);    }  if (l1 || l2)    {      D(("WARNING -- list length inconsistency./n"));      D_RETURN_(FALSE);    }  D_RETURN_(TRUE);}

int       __bro_openssl_read(BroConn *bc, uchar *buf, uint buf_size){  int n;  D_ENTER;    /* It's important here to use <= for comparison, since, as the   * invaluable O'Reilly OpenSSL book reports, "for each of the four   * reading and writing functions, a 0 or -1 return value may or may   * not necessarily indicate that an error has occurred." This may or   * may not necessarily be indicative of the incredible PITA that   * OpenSSL is. --cpk   */  if ( (n = BIO_read(bc->bio, buf, buf_size)) <= 0)    {      if (BIO_should_retry(bc->bio))	D_RETURN_(0);            __bro_openssl_shutdown(bc);      D(("Connection closed, BIO_read() returned %i./n", n));            print_errors();      D_RETURN_(-1);    }      D_RETURN_(n);}

int__bro_io_packet_queue(BroConn *bc, BroPacket *packet){  BroPacket *clone;  BroMsg *msg;  int result;  D_ENTER;  if (!bc)    D_RETURN_(FALSE);  if (! (msg = __bro_io_msg_new(BRO_MSG_SERIAL, 0)))    D_RETURN_(FALSE);  if (! (clone = bro_packet_clone(packet)))    {      __bro_io_msg_free(msg);      D_RETURN_(FALSE);    }    __bro_io_msg_set_cont(msg, BRO_MSG_CONT_PACKET, clone);  result = io_msg_queue(bc, msg);  D_RETURN_(result);}

int__bro_list_val_get_length(BroListVal *lv){  D_ENTER;  if (! lv)    D_RETURN_(0);  D_RETURN_(lv->len);}

int__bro_vector_get_length(BroVector *vec)	{	D_ENTER;	if ( ! vec )		D_RETURN_(0);	D_RETURN_(vec->length);	}

int__bro_sobject_write(BroSObject *obj, BroConn *bc){  D_ENTER;    if (! __bro_buf_write_short(bc->tx_buf, obj->type_id))    D_RETURN_(FALSE);    D_RETURN_(TRUE);}

int__bro_sobject_cmp(BroSObject *obj1, BroSObject *obj2){  D_ENTER;  if (! obj1 || !obj2)    D_RETURN_(FALSE);  D_RETURN_(obj1->cmp(obj1, obj2));}

uint32__bro_sobject_hash(BroSObject *obj){  D_ENTER;  if (! obj)    D_RETURN_(0);  D_RETURN_(obj->hash(obj));}

int__bro_id_cmp(BroID *id1, BroID *id2){  D_ENTER;  if (! id1 || ! id2)    D_RETURN_(FALSE);  D_RETURN_(__bro_ht_str_cmp(id1->name.str_val, id2->name.str_val));}

BroVal *__bro_list_val_get_front(BroListVal *lv){  BroVal *result;  BroList *l;  D_ENTER;  if (! lv)    D_RETURN_(NULL);  D_RETURN_((BroVal*) __bro_list_data(lv->list));}

static int__bro_record_val_clone(BroRecordVal *dst, BroRecordVal *src){  D_ENTER;  if (! __bro_mutable_val_clone((BroMutableVal *) dst, (BroMutableVal *) src))    D_RETURN_(FALSE);  if (src->rec && ! (dst->rec = __bro_record_copy(src->rec)))    D_RETURN_(FALSE);  D_RETURN_(TRUE);}

static int__bro_table_val_clone(BroTableVal *dst, BroTableVal *src){  D_ENTER;  if (! __bro_mutable_val_clone((BroMutableVal *) dst, (BroMutableVal *) src))    D_RETURN_(FALSE);  if (src->table && ! (dst->table = __bro_table_copy(src->table)))    D_RETURN_(FALSE);  D_RETURN_(TRUE);}

static int__bro_sobject_cmp_impl(BroSObject *obj1, BroSObject *obj2){  D_ENTER;    if (! obj1 || ! obj2)    D_RETURN_(FALSE);    if (obj1->perm_id != obj2->perm_id)    D_RETURN_(FALSE);    D_RETURN_(TRUE);}

static int__bro_val_cmp(BroVal *val1, BroVal *val2){  int i;  D_ENTER;  if (! val1 || ! val2)    D_RETURN_(FALSE);  if (! __bro_sobject_cmp((BroSObject*) val1->val_type,			  (BroSObject*) val2->val_type))    D_RETURN_(FALSE);  switch (val1->val_type->internal_tag)    {    case BRO_INTTYPE_INT:    case BRO_INTTYPE_UNSIGNED:      if (val1->val_int64 != val2->val_int64)	D_RETURN_(FALSE);      break;    case BRO_INTTYPE_IPADDR:      for (i = 3; i >= 0; --i)        if (val1->val_addr.addr[i] != val2->val_addr.addr[i])          D_RETURN_(FALSE);      break;    case BRO_INTTYPE_DOUBLE:      if (val1->val_double != val2->val_double)	D_RETURN_(FALSE);      break;    case BRO_INTTYPE_STRING:      if (! __bro_ht_str_cmp(val1->val_str.str_val, val2->val_str.str_val))	D_RETURN_(FALSE);      break;    case BRO_INTTYPE_SUBNET:      for (i = 3; i >= 0; --i)        if (val1->val_subnet.sn_net.addr[i] != val2->val_subnet.sn_net.addr[i])          D_RETURN_(FALSE);      if (val1->val_subnet.sn_width != val2->val_subnet.sn_width)        D_RETURN_(FALSE);      break;    case BRO_INTTYPE_OTHER:      D(("WARNING -- __bro_val_cmp() invoked on derived type./n"));      break;    default:      D(("Unknown internal type tag: %i/n", val1->val_type->internal_tag));      break;    }  D_RETURN_(TRUE);}

static uint32__bro_val_hash(BroVal *val){  uint32 result;  int i;  D_ENTER;  if (! val)    D_RETURN_(0);  result = __bro_sobject_hash((BroSObject*) val->val_type);  switch (val->val_type->internal_tag)    {    case BRO_INTTYPE_INT:    case BRO_INTTYPE_UNSIGNED:      result ^= val->val_int64;      break;    case BRO_INTTYPE_IPADDR:      for ( i = 0; i < 4; ++i )        result ^= val->val_addr.addr[i];      break;    case BRO_INTTYPE_DOUBLE:      result ^= (uint32) val->val_double;      break;    case BRO_INTTYPE_STRING:      result ^= __bro_ht_str_hash(val->val_str.str_val);      break;    case BRO_INTTYPE_SUBNET:      for ( i = 0; i < 4; ++i )        result ^= val->val_subnet.sn_net.addr[i];      result ^= val->val_subnet.sn_width;      break;    case BRO_INTTYPE_OTHER:      D(("WARNING -- __bro_val_hash() invoked on derived type./n"));      break;    default:      D(("Unknown internal type tag: %i/n", val->val_type->internal_tag));      break;    }  D_RETURN_(result);}

static int__bro_record_val_cmp(BroRecordVal *rv1, BroRecordVal *rv2){  D_ENTER;  if (! rv1 || ! rv2)    D_RETURN_(FALSE);  if (! __bro_record_cmp(rv1->rec, rv2->rec))    D_RETURN_(FALSE);  D_RETURN_(TRUE);}

BroID *__bro_id_new(void){  BroID *id;  D_ENTER;  if (! (id = calloc(1, sizeof(BroID))))    D_RETURN_(NULL);  __bro_id_init(id);  D_RETURN_(id);}

BroVal *__bro_val_new(void){  BroVal *val;  D_ENTER;  if (! (val = calloc(1, sizeof(BroVal))))    D_RETURN_(NULL);  __bro_val_init(val);  D_RETURN_(val);}