int dhcp_network_send_raw_socket(int s, const union sockaddr_union *link, const void *packet, size_t len) { size_t size; _cleanup_free_ DHCPPacket *discover; uint16_t ip_check, udp_check; assert_se(s >= 0); assert_se(packet); size = sizeof(DHCPPacket); assert_se(len > size); discover = memdup(packet, len); assert_se(discover->ip.ttl == IPDEFTTL); assert_se(discover->ip.protocol == IPPROTO_UDP); assert_se(discover->ip.saddr == INADDR_ANY); assert_se(discover->ip.daddr == INADDR_BROADCAST); assert_se(discover->udp.source == be16toh(DHCP_PORT_CLIENT)); assert_se(discover->udp.dest == be16toh(DHCP_PORT_SERVER)); ip_check = discover->ip.check; discover->ip.ttl = 0; discover->ip.check = discover->udp.len; udp_check = ~dhcp_packet_checksum(&discover->ip.ttl, len - 8); assert_se(udp_check == 0xffff); discover->ip.ttl = IPDEFTTL; discover->ip.check = ip_check; ip_check = ~dhcp_packet_checksum(&discover->ip, sizeof(discover->ip)); assert_se(ip_check == 0xffff); assert_se(discover->dhcp.xid); assert_se(memcmp(discover->dhcp.chaddr, &mac_addr.ether_addr_octet, 6) == 0); size = len - sizeof(struct iphdr) - sizeof(struct udphdr); assert_se(callback_recv); callback_recv(size, &discover->dhcp); return 575; }
// calculate the list of players for a given game with geolocation static char* list_game_with_geolocation(const struct game * g) { char list_game_str[8192] = ""; int i; char* n; for (i = 0; i < g->players_number; i++) { strconcat(list_game_str, g->players_nick[i], sizeof(list_game_str)); n = geoloc[g->players_conn[i]]; if (n != NULL) { strconcat(list_game_str, ":", sizeof(list_game_str)); strconcat(list_game_str, n, sizeof(list_game_str)); } if (i < g->players_number - 1) strconcat(list_game_str, ",", sizeof(list_game_str)); } return memdup(list_game_str, strlen(list_game_str) + 1); }
bool charset_register_backend(const void *_funcs) { struct charset_functions *funcs = (struct charset_functions *)memdup(_funcs,sizeof(struct charset_functions)); struct charset_functions *c; /* Check whether we already have this charset... */ for (c = charsets; c != NULL; c = c->next) { if(!strcasecmp(c->name, funcs->name)) { DEBUG(2, ("Duplicate charset %s, not registering\n", funcs->name)); return false; } } funcs->next = funcs->prev = NULL; DLIST_ADD(charsets, funcs); return true; }
static scamper_fd_t *fd_icmp(int type, void *addr) { scamper_fd_t *fdn = NULL, findme; size_t len = 0; int fd = -1; findme.type = type; findme.fd_icmp_addr = addr; if((fdn = fd_find(&findme)) != NULL) { return fdn; } if(type == SCAMPER_FD_TYPE_ICMP4) { fd = scamper_icmp4_open(addr); len = sizeof(struct in_addr); } else if(type == SCAMPER_FD_TYPE_ICMP6) { fd = scamper_icmp6_open(addr); len = sizeof(struct in6_addr); } if(fd == -1 || (fdn = fd_alloc(type, fd)) == NULL || (addr != NULL && (fdn->fd_icmp_addr = memdup(addr, len)) == NULL) || (fdn->fd_tree_node = splaytree_insert(fd_tree, fdn)) == NULL || (fdn->fd_list_node = dlist_tail_push(fd_list, fdn)) == NULL) { goto err; } return fdn; err: if(fd != -1) { if(type == SCAMPER_FD_TYPE_ICMP4) scamper_icmp4_close(fd); else if(type == SCAMPER_FD_TYPE_ICMP6) scamper_icmp6_close(fd); } if(fdn != NULL) fd_free(fdn); return NULL; }
/** * sets a given column in a row with data given a type, value, and * length. Data is memdup'ed by the function. */ int netsnmp_set_row_column(netsnmp_table_row *row, unsigned int column, int type, const char *value, size_t value_len) { netsnmp_table_data_set_storage *data; if (!row) return SNMPERR_GENERR; data = (netsnmp_table_data_set_storage *) row->data; data = netsnmp_table_data_set_find_column(data, column); if (!data) { /* * create it */ data = SNMP_MALLOC_TYPEDEF(netsnmp_table_data_set_storage); if (!data) { snmp_log(LOG_CRIT, "no memory in netsnmp_set_row_column"); return SNMPERR_MALLOC; } data->column = column; data->type = type; data->next = row->data; row->data = data; } if (value) { if (data->type != type) return SNMPERR_GENERR; SNMP_FREE(data->data.voidp); if (value_len) { if (memdup(&data->data.string, value, (value_len)) != SNMPERR_SUCCESS) { snmp_log(LOG_CRIT, "no memory in netsnmp_set_row_column"); return SNMPERR_MALLOC; } } else { data->data.string = malloc(1); } data->data_len = value_len; } return SNMPERR_SUCCESS; }
BOOL cli_qfileinfo_test(struct cli_state *cli, int fnum, int level, char **poutdata, uint32 *poutlen) { unsigned int data_len = 0; unsigned int param_len = 0; uint16 setup = TRANSACT2_QFILEINFO; pstring param; char *rparam=NULL, *rdata=NULL; *poutdata = NULL; *poutlen = 0; /* if its a win95 server then fail this - win95 totally screws it up */ if (cli->win95) return False; param_len = 4; memset(param, 0, param_len); SSVAL(param, 0, fnum); SSVAL(param, 2, level); if (!cli_send_trans(cli, SMBtrans2, NULL, /* name */ -1, 0, /* fid, flags */ &setup, 1, 0, /* setup, length, max */ param, param_len, 2, /* param, length, max */ NULL, data_len, cli->max_xmit /* data, length, max */ )) { return False; } if (!cli_receive_trans(cli, SMBtrans2, &rparam, ¶m_len, &rdata, &data_len)) { return False; } *poutdata = memdup(rdata, data_len); *poutlen = data_len; SAFE_FREE(rdata); SAFE_FREE(rparam); return True; }
/** * Create single node of data element. * @param nm: name (copied) * @param nm_len: length of name * @param labs: labels in name. * @return element with name nm, or NULL malloc failure. */ static struct val_neg_data* neg_setup_data_node( uint8_t* nm, size_t nm_len, int labs) { struct val_neg_data* el; el = (struct val_neg_data*)calloc(1, sizeof(*el)); if(!el) { return NULL; } el->node.key = el; el->name = memdup(nm, nm_len); if(!el->name) { free(el); return NULL; } el->len = nm_len; el->labs = labs; return el; }
void init_unistr2_from_datablob(UNISTR2 *str, DATA_BLOB *blob) { /* Allocs the unistring */ init_unistr2(str, NULL, UNI_FLAGS_NONE); /* Sets the values */ str->uni_str_len = blob->length / sizeof(uint16); str->uni_max_len = str->uni_str_len; str->offset = 0; if (blob->length) { str->buffer = (uint16 *) memdup(blob->data, blob->length); } else { str->buffer = NULL; } if ((str->buffer == NULL) && (blob->length > 0)) { smb_panic("init_unistr2_from_datablob: malloc fail\n"); } }
PrintData(BaseEngine *engine, PRINTER_INFO_2 *printerInfo, DEVMODE *devMode, Vec<PRINTPAGERANGE> &ranges, Print_Advanced_Data &advData, int rotation = 0, Vec<SelectionOnPage> *sel = nullptr) : engine(nullptr), advData(advData), rotation(rotation) { if (engine) this->engine = engine->Clone(); if (printerInfo) { printerName.Set(str::Dup(printerInfo->pPrinterName)); } if (devMode) this->devMode.Set((LPDEVMODE)memdup(devMode, devMode->dmSize + devMode->dmDriverExtra)); if (!sel) this->ranges = ranges; else this->sel = *sel; }
void agentx_register_callbacks (netsnmp_session * s) { netsnmp_session *sess_p; DEBUGMSGTL (("agentx/subagent", "registering callbacks for session %p\n", s)); memdup ((u_char **) & sess_p, &s, sizeof (s)); netsnmp_assert (sess_p); s->myvoid = sess_p; if (!sess_p) return; snmp_register_callback (SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_SHUTDOWN, subagent_shutdown, sess_p); snmp_register_callback (SNMP_CALLBACK_APPLICATION, SNMPD_CALLBACK_REGISTER_OID, agentx_registration_callback, sess_p); snmp_register_callback (SNMP_CALLBACK_APPLICATION, SNMPD_CALLBACK_UNREGISTER_OID, agentx_registration_callback, sess_p); snmp_register_callback (SNMP_CALLBACK_APPLICATION, SNMPD_CALLBACK_REG_SYSOR, agentx_sysOR_callback, sess_p); snmp_register_callback (SNMP_CALLBACK_APPLICATION, SNMPD_CALLBACK_UNREG_SYSOR, agentx_sysOR_callback, sess_p); }
/** setup query list in info */ static void qlist_add_line(struct perfinfo* info, char* line, int no) { if(!qlist_parse_line(info->buf, line)) { printf("error parsing query %d: %s\n", no, line); exit(1); } sldns_buffer_write_u16_at(info->buf, 0, (uint16_t)info->qlist_size); if(info->qlist_size + 1 > info->qlist_capacity) { qlist_grow_capacity(info); } info->qlist_len[info->qlist_size] = sldns_buffer_limit(info->buf); info->qlist_data[info->qlist_size] = memdup( sldns_buffer_begin(info->buf), sldns_buffer_limit(info->buf)); if(!info->qlist_data[info->qlist_size]) fatal_exit("out of memory"); info->qlist_size ++; }
t_args get_c_len(va_list ap, int *f) { t_args a; wchar_t c; (void)f; c = va_arg(ap, wchar_t); a.args = memdup(&c, sizeof(c)); if (c <= 0x7F) a.arg_size = 1; else if (c <= 0x7FF) a.arg_size = 2; else if (c <= 0xFFFF) a.arg_size = 3; else if (c <= 0x10FFFF) a.arg_size = 4; return (a); }
int netsnmp_table_data_copy_row( netsnmp_table_row *old_row, netsnmp_table_row *new_row ) { if (!old_row || !new_row) return -1; memcpy(new_row, old_row, sizeof(netsnmp_table_row)); if (old_row->indexes) new_row->indexes = snmp_clone_varbind(old_row->indexes); if (old_row->index_oid) memdup((u_char **) & new_row->index_oid, (u_char *) old_row->index_oid, old_row->index_oid_len * sizeof(oid)); /* XXX - Doesn't copy table-specific row structure */ return 0; }
static int ga_extcopy(GpuArray *dst, const GpuArray *src) { struct extcopy_args a, *aa; gpucontext *ctx = gpudata_context(dst->data); GpuElemwise *k = NULL; void *args[2]; if (ctx != gpudata_context(src->data)) return GA_INVALID_ERROR; a.itype = src->typecode; a.otype = dst->typecode; if (ctx->extcopy_cache != NULL) k = cache_get(ctx->extcopy_cache, &a); if (k == NULL) { gpuelemwise_arg gargs[2]; gargs[0].name = "src"; gargs[0].typecode = src->typecode; gargs[0].flags = GE_READ; gargs[1].name = "dst"; gargs[1].typecode = dst->typecode; gargs[1].flags = GE_WRITE; k = GpuElemwise_new(ctx, "", "dst = src", 2, gargs, 0, 0); if (k == NULL) return GA_MISC_ERROR; aa = memdup(&a, sizeof(a)); if (aa == NULL) { GpuElemwise_free(k); return GA_MEMORY_ERROR; } if (ctx->extcopy_cache == NULL) ctx->extcopy_cache = cache_twoq(4, 8, 8, 2, extcopy_eq, extcopy_hash, extcopy_free, (cache_freev_fn)GpuElemwise_free, ctx->err); if (ctx->extcopy_cache == NULL) return GA_MISC_ERROR; if (cache_add(ctx->extcopy_cache, aa, k) != 0) return GA_MISC_ERROR; } args[0] = (void *)src; args[1] = (void *)dst; return GpuElemwise_call(k, args, GE_BROADCAST); }
/** add result to the bg worker result queue */ static void add_bg_result(struct libworker* w, struct ctx_query* q, sldns_buffer* pkt, int err, char* reason) { uint8_t* msg = NULL; uint32_t len = 0; if(w->want_quit) { context_query_delete(q); return; } /* serialize and delete unneeded q */ if(w->is_bg_thread) { lock_basic_lock(&w->ctx->cfglock); if(reason) q->res->why_bogus = strdup(reason); if(pkt) { q->msg_len = sldns_buffer_remaining(pkt); q->msg = memdup(sldns_buffer_begin(pkt), q->msg_len); if(!q->msg) msg = context_serialize_answer(q, UB_NOMEM, NULL, &len); else msg = context_serialize_answer(q, err, NULL, &len); } else msg = context_serialize_answer(q, err, NULL, &len); lock_basic_unlock(&w->ctx->cfglock); } else { if(reason) q->res->why_bogus = strdup(reason); msg = context_serialize_answer(q, err, pkt, &len); (void)rbtree_delete(&w->ctx->queries, q->node.key); w->ctx->num_async--; context_query_delete(q); } if(!msg) { log_err("out of memory for async answer"); return; } if(!tube_queue_item(w->ctx->rr_pipe, msg, len)) { log_err("out of memory for async answer"); return; } }
/** * insert a new-PTR entry in message * */ void DNSUpdate::addinMsg_newPTR(){ DnsRR rr; const int bufSize = 128; char destination[16]; char result[bufSize]; memset(result, 0, bufSize); inet_pton6(hostip, destination); doRevDnsAddress(destination,result); rr.NAME = result; rr.TYPE = qtype_getcode("PTR", false); rr.TTL = txt_to_int(ttl); string tmp = string(_hostname); string data = rr_fromstring(rr.TYPE, tmp.c_str()); rr.RDLENGTH = data.size(); rr.RDATA = (unsigned char*)memdup(data.c_str(), rr.RDLENGTH); message->authority.push_back(rr); Log(Debug) << "DDNS: PTR record created: " << result << " -> " << tmp << LogEnd; }
regclass_t regclass(const char* s, char** e) { register Ctype_t* cp; register int c; register size_t n; register const char* t; if (c = *s++) { for (t = s; *t && (*t != c || *(t + 1) != ']'); t++); if (*t != c) return 0; n = t - s; for (cp = ctypes; cp; cp = cp->next) if (n == cp->size && strneq(s, cp->name, n)) goto found; for (cp = ctype; cp < &ctype[elementsof(ctype)]; cp++) { #if _lib_wctype if (!cp->size && (cp->name = (const char*)memdup(s, n + 1))) { *((char*)cp->name + n) = 0; /* mvs.390 needs the (char*) cast -- barf */ if (!(cp->wtype = wctype((char*)cp->name))) { free((char*)cp->name); return 0; } cp->size = n; goto found; } #endif if (n == cp->size && strneq(s, cp->name, n)) goto found; } } return 0; found: if (e) *e = (char*)t + 2; return cp->ctype; }
void addr_add(array_t *addresses, struct kernel_address *addr) { struct kernel_address *copy = NULL; int rc; copy = memdup(addr, sizeof(struct kernel_address)); if (!copy) goto fail; rc = array_add(addresses, copy, (cmp_fun_t)addr_cmp); if (rc < 0) goto fail2; return; fail2: free(copy); fail: log_msg(LOG_PERROR, "Fail to add address"); return; }
static int dealias_ipid32_bo(scamper_dealias_probe_t **probes, int probec) { scamper_dealias_probe_t **s = NULL; uint32_t a, b, c = 1, max_bs = 0, max_nobs = 0, u32; int i, rc = 2; if((s = memdup(probes, sizeof(scamper_dealias_probe_t *) * probec)) == NULL) return -1; array_qsort((void **)s, probec, (array_cmp_t)dealias_probe_def_cmp); for(i=0; i<probec-1; i++) { if(s[i]->def != s[i+1]->def) { if(c >= 3) { if(max_nobs < max_bs) rc = 0; else if(max_nobs > max_bs) rc = 1; if(rc == 0) goto done; } c = 1; max_nobs = 0; max_bs = 0; } else { a = s[i]->replies[0]->ipid32; b = s[i+1]->replies[0]->ipid32; u32 = dealias_ipid32_diff(a, b); if(u32 > max_nobs || max_nobs == 0) max_nobs = u32; u32 = dealias_ipid32_diff(byteswap32(a), byteswap32(b)); if(u32 > max_bs || max_bs == 0) max_bs = u32; c++; } } done: if(s != NULL) free(s); return rc; }
int dns_trust_anchor_load(DnsTrustAnchor *d) { _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL; _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL; int r; assert(d); r = hashmap_ensure_allocated(&d->by_key, &dns_resource_key_hash_ops); if (r < 0) return r; if (hashmap_get(d->by_key, &DNS_RESOURCE_KEY_CONST(DNS_CLASS_IN, DNS_TYPE_DS, "."))) return 0; /* Add the RR from https://data.iana.org/root-anchors/root-anchors.xml */ rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_DS, ""); if (!rr) return -ENOMEM; rr->ds.key_tag = 19036; rr->ds.algorithm = DNSSEC_ALGORITHM_RSASHA256; rr->ds.digest_type = DNSSEC_DIGEST_SHA256; rr->ds.digest_size = sizeof(root_digest); rr->ds.digest = memdup(root_digest, rr->ds.digest_size); if (!rr->ds.digest) return -ENOMEM; answer = dns_answer_new(1); if (!answer) return -ENOMEM; r = dns_answer_add(answer, rr, 0); if (r < 0) return r; r = hashmap_put(d->by_key, rr->key, answer); if (r < 0) return r; answer = NULL; return 0; }
// idxi is index of input element // row is the input row // y is the output vector (part) for the input row //doProcess(int idxi, cMatrix *row, FLOAT_DMEM*y) int cFunctionalsVecToVec::processVectorFloat(const FLOAT_DMEM *src, FLOAT_DMEM *dst, long Nsrc, long Ndst, int idxi) { // copy row to matrix... simple memcpy here // memcpy(y,row->dataF,row->nT*sizeof(FLOAT_DMEM)); // return the number of components in y!! int i; int ok=0; FLOAT_DMEM * unsorted = (FLOAT_DMEM*)memdup(src,sizeof(FLOAT_DMEM)*Nsrc); FLOAT_DMEM * sorted=NULL; if (requireSorted) { sorted = (FLOAT_DMEM*)malloc(sizeof(FLOAT_DMEM)*Nsrc); // quicksort: memcpy( sorted, unsorted, sizeof(FLOAT_DMEM) * Nsrc ); // TODO: check for float_dmem::: with #if ... #if FLOAT_DMEM_NUM == FLOAT_DMEM_FLOAT smileUtil_quickSort_float(sorted, Nsrc); #else smileUtil_quickSort_double(sorted, Nsrc); #endif } for (i=0; i<nFunctionalsEnabled; i++) { if (functObj[i] != NULL) { int ret; ret = functObj[i]->process( unsorted, sorted, dst+i, Nsrc, functN[i] ); if (ret < functN[i]) { int j; for (j=ret; j<functN[i]; j++) dst[j] = 0.0; } if (ret>0) ok++; } } if (requireSorted) { free(sorted); } free(unsorted); return nFunctValues; }
void set_sec_ctx(uid_t uid, gid_t gid, int ngroups, gid_t *groups, NT_USER_TOKEN *token) { struct sec_ctx *ctx_p = &sec_ctx_stack[sec_ctx_stack_ndx]; /* Set the security context */ DEBUG(3, ("setting sec ctx (%u, %u) - sec_ctx_stack_ndx = %d\n", (unsigned int)uid, (unsigned int)gid, sec_ctx_stack_ndx)); debug_nt_user_token(DBGC_CLASS, 5, token); debug_unix_user_token(DBGC_CLASS, 5, uid, gid, ngroups, groups); gain_root(); #ifdef HAVE_SETGROUPS sys_setgroups(ngroups, groups); #endif ctx_p->ngroups = ngroups; SAFE_FREE(ctx_p->groups); if (token && (token == ctx_p->token)) smb_panic("DUPLICATE_TOKEN"); delete_nt_token(&ctx_p->token); ctx_p->groups = memdup(groups, sizeof(gid_t) * ngroups); ctx_p->token = dup_nt_token(token); become_id(uid, gid); ctx_p->uid = uid; ctx_p->gid = gid; /* Update current_user stuff */ current_user.uid = uid; current_user.gid = gid; current_user.ngroups = ngroups; current_user.groups = groups; current_user.nt_user_token = ctx_p->token; }
void rr_read(u_int16 RRTYPE, unsigned char*& RDATA, uint16_t &RDLEN, message_buff &buff, int ix, int len) { rr_type *info = rrtype_getinfo(RRTYPE); char *ptr; stl_string res; _domain dom; if (ix + len > buff.len) throw PException("RR doesn't fit in DNS message"); if (info) { /* we support the RR type */ try { ptr = info->properties; while (*ptr) { int x; x = rr_len(*ptr, buff, ix, len); if (x > len) throw PException("RR item too long!"); if (*ptr == 'd' || *ptr == 'm') { /* domain name: needs to be decompressed */ dom = dom_uncompress(buff, ix); res.append((char*)dom, domlen(dom)); free(dom); } else { res.append((char*)buff.msg + ix, x); } ix += x; len -= x; ptr++; } if (len != 0) throw PException("extra data in RR"); } catch(PException p) { throw PException("Parsing RR failed: ", p); } if (len != 0) throw PException("RR length too long"); } else { /* we do not support the RR type: just copy it altogether */ res.append((char*)buff.msg + ix, len); } RDLEN = res.length(); RDATA = (unsigned char *)memdup((void *)res.c_str(), res.length()); }
// gets a dialog template from the resources and sets the RTL flag // cf. http://www.ureader.com/msg/1484387.aspx static DLGTEMPLATE *GetRtLDlgTemplate(int dlgId) { HRSRC dialogRC = FindResource(NULL, MAKEINTRESOURCE(dlgId), RT_DIALOG); if (!dialogRC) return NULL; HGLOBAL dlgTemplate = LoadResource(NULL, dialogRC); if (!dlgTemplate) return NULL; void *origDlgTemplate = LockResource(dlgTemplate); size_t size = SizeofResource(NULL, dialogRC); DLGTEMPLATE *rtlDlgTemplate = (DLGTEMPLATE *)memdup(origDlgTemplate, size); if (rtlDlgTemplate->style == MAKELONG(0x0001, 0xFFFF)) ((DLGTEMPLATEEX *)rtlDlgTemplate)->exStyle |= WS_EX_LAYOUTRTL; else rtlDlgTemplate->dwExtendedStyle |= WS_EX_LAYOUTRTL; UnlockResource(dlgTemplate); return rtlDlgTemplate; }
static int solver(const int *orig, int w, int h, char **solution) { const int sz = w * h; struct solver_state ss; ss.board = memdup(orig, sz, sizeof (int)); ss.dsf = snew_dsf(sz); /* eqv classes: connected components */ ss.connected = snewn(sz, int); /* connected[n] := n.next; */ /* cyclic disjoint singly linked lists, same partitioning as dsf. * The lists lets you iterate over a partition given any member */ printv("trying to solve this:\n"); print_board(ss.board, w, h); init_solver_state(&ss, w, h); do { if (learn_blocked_expansion(&ss, w, h)) continue; if (learn_expand_or_one(&ss, w, h)) continue; if (learn_critical_square(&ss, w, h)) continue; break; } while (ss.nempty); printv("best guess:\n"); print_board(ss.board, w, h); if (solution) { int i; assert(*solution == NULL); *solution = snewn(sz + 2, char); **solution = 's'; for (i = 0; i < sz; ++i) (*solution)[i + 1] = ss.board[i] + '0'; (*solution)[sz + 1] = '\0'; /* We don't need the \0 for execute_move (the only user) * I'm just being printf-friendly in case I wanna print */ } sfree(ss.dsf); sfree(ss.board); sfree(ss.connected); return !ss.nempty; }
/** parse commandline argument domain name */ static int parse_arg_name(SSL* ssl, char* str, uint8_t** res, size_t* len, int* labs) { ldns_rdf* rdf; *res = NULL; *len = 0; *labs = 0; rdf = ldns_dname_new_frm_str(str); if(!rdf) { ssl_printf(ssl, "error cannot parse name %s\n", str); return 0; } *res = memdup(ldns_rdf_data(rdf), ldns_rdf_size(rdf)); ldns_rdf_deep_free(rdf); if(!*res) { ssl_printf(ssl, "error out of memory\n"); return 0; } *labs = dname_count_size_labels(*res, len); return 1; }
/* retrieve the region data for sending to the client and free the region at the same time */ rectangle_t *get_region_data_and_free(struct region *region, data_size_t max_size, data_size_t *total_size) { rectangle_t *ret = region->rects; if (!(*total_size = region->num_rects * sizeof(rectangle_t))) { /* return a single empty rect for empty regions */ *total_size = sizeof(empty_rect); if (max_size >= sizeof(empty_rect)) { ret = memdup(&empty_rect, sizeof(empty_rect)); free(region->rects); } } if (max_size < *total_size) { free(region->rects); set_error(STATUS_BUFFER_OVERFLOW); ret = NULL; } free(region); return ret; }
/** return name and class of rr; parses string */ static int get_rr_nameclass(const char* str, uint8_t** nm, uint16_t* dclass) { uint8_t rr[LDNS_RR_BUF_SIZE]; size_t len = sizeof(rr), dname_len = 0; int s = sldns_str2wire_rr_buf(str, rr, &len, &dname_len, 3600, NULL, 0, NULL, 0); if(s != 0) { log_err("error parsing local-data at %d '%s': %s", LDNS_WIREPARSE_OFFSET(s), str, sldns_get_errorstr_parse(s)); return 0; } *nm = memdup(rr, dname_len); *dclass = sldns_wirerr_get_class(rr, len, dname_len); if(!*nm) { log_err("out of memory"); return 0; } return 1; }
/** * Create a single zone node * @param nm: name for zone (copied) * @param nm_len: length of name * @param labs: labels in name. * @param dclass: class of zone, host order. * @return new zone or NULL on failure */ static struct val_neg_zone* neg_setup_zone_node( uint8_t* nm, size_t nm_len, int labs, uint16_t dclass) { struct val_neg_zone* zone = (struct val_neg_zone*)calloc(1, sizeof(*zone)); if(!zone) { return NULL; } zone->node.key = zone; zone->name = memdup(nm, nm_len); if(!zone->name) { free(zone); return NULL; } zone->len = nm_len; zone->labs = labs; zone->dclass = dclass; rbtree_init(&zone->tree, &val_neg_data_compare); return zone; }
NT_USER_TOKEN *dup_nt_token(NT_USER_TOKEN *ptoken) { NT_USER_TOKEN *token; if (!ptoken) return NULL; if ((token = (NT_USER_TOKEN *)malloc( sizeof(NT_USER_TOKEN) ) ) == NULL) return NULL; ZERO_STRUCTP(token); if ((token->user_sids = (DOM_SID *)memdup( ptoken->user_sids, sizeof(DOM_SID) * ptoken->num_sids )) == NULL) { SAFE_FREE(token); return NULL; } token->num_sids = ptoken->num_sids; return token; }