static void pam_handle_cached_login(struct pam_auth_req *preq, int ret, time_t expire_date, time_t delayed_until) { uint32_t resp_type; size_t resp_len; uint8_t *resp; int64_t dummy; preq->pd->pam_status = cached_login_pam_status(ret); switch (preq->pd->pam_status) { case PAM_SUCCESS: resp_type = SSS_PAM_USER_INFO_OFFLINE_AUTH; resp_len = sizeof(uint32_t) + sizeof(int64_t); resp = talloc_size(preq->pd, resp_len); if (resp == NULL) { DEBUG(SSSDBG_CRIT_FAILURE, "talloc_size failed, cannot prepare user info.\n"); } else { memcpy(resp, &resp_type, sizeof(uint32_t)); dummy = (int64_t) expire_date; memcpy(resp+sizeof(uint32_t), &dummy, sizeof(int64_t)); ret = pam_add_response(preq->pd, SSS_PAM_USER_INFO, resp_len, (const uint8_t *) resp); if (ret != EOK) { DEBUG(SSSDBG_CRIT_FAILURE, "pam_add_response failed.\n"); } } break; case PAM_PERM_DENIED: if (delayed_until >= 0) { resp_type = SSS_PAM_USER_INFO_OFFLINE_AUTH_DELAYED; resp_len = sizeof(uint32_t) + sizeof(int64_t); resp = talloc_size(preq->pd, resp_len); if (resp == NULL) { DEBUG(SSSDBG_CRIT_FAILURE, "talloc_size failed, cannot prepare user info.\n"); } else { memcpy(resp, &resp_type, sizeof(uint32_t)); dummy = (int64_t) delayed_until; memcpy(resp+sizeof(uint32_t), &dummy, sizeof(int64_t)); ret = pam_add_response(preq->pd, SSS_PAM_USER_INFO, resp_len, (const uint8_t *) resp); if (ret != EOK) { DEBUG(SSSDBG_CRIT_FAILURE, "pam_add_response failed.\n"); } } } break; default: DEBUG(SSSDBG_TRACE_LIBS, "cached login returned: %d\n", preq->pd->pam_status); } pam_reply(preq); return; }
/** \details Return the list of pending mapistore notifications available on the queue name specified in argument. \param mstore_ctx pointer to the mapistore context \param mqueue_name the name of the queue to open \param nl pointer on pointer to the list of mapistore notifications to return \return MAPISTORE_SUCCESS on success, otherwise MAPISTORE error. */ _PUBLIC_ enum MAPISTATUS mapistore_get_queued_notifications_named(struct mapistore_context *mstore_ctx, const char *mqueue_name, struct mapistore_notification_list **nl) { int ret; mqd_t mqueue; struct mapistore_notification_list *nlist = NULL; struct mapistore_notification_list *el = NULL; unsigned int prio; struct mq_attr attr; DATA_BLOB data; bool found = false; printf("[%s:%d]: queue name = %s\n", __FUNCTION__, __LINE__, ((mqueue_name) ? mqueue_name : NULL)); /* Sanity checks */ MAPISTORE_RETVAL_IF(!mstore_ctx, MAPISTORE_ERR_NOT_INITIALIZED, NULL); MAPISTORE_RETVAL_IF(!nl, MAPISTORE_ERR_INVALID_PARAMETER, NULL); mqueue = mq_open(mqueue_name, O_RDONLY|O_NONBLOCK|O_CREAT, 0777, NULL); if (mqueue == -1) { perror("mq_open"); return MAPISTORE_ERR_NOT_INITIALIZED; } /* Retrieve queue attributes */ ret = mq_getattr(mqueue, &attr); if (ret == -1) { perror("mq_getattr"); /* set proper error message here and remove above */ if (mq_close(mqueue) == -1) { perror("mq_close"); } MAPISTORE_RETVAL_IF(ret == -1, MAPISTORE_ERR_NOT_FOUND, NULL); } data.data = talloc_size((TALLOC_CTX *)mstore_ctx, attr.mq_msgsize); while ((data.length = mq_receive(mqueue, (char *)data.data, attr.mq_msgsize, &prio)) != -1) { printf("* we received a notification on queue %s\n", mqueue_name); if (!nlist) { nlist = talloc_zero((TALLOC_CTX *)mstore_ctx, struct mapistore_notification_list); } el = mapistore_notification_process_mqueue_notif((TALLOC_CTX *)nlist, data); printf("* processing notification returned %p\n", el); if (el) { DLIST_ADD_END(nlist, el, struct mapistore_notification_list); } talloc_free(data.data); found = true; data.data = talloc_size((TALLOC_CTX *)mstore_ctx, attr.mq_msgsize); }
struct tsocket_address *_tsocket_address_create(TALLOC_CTX *mem_ctx, const struct tsocket_address_ops *ops, void *pstate, size_t psize, const char *type, const char *location) { void **ppstate = (void **)pstate; struct tsocket_address *addr; addr = talloc_zero(mem_ctx, struct tsocket_address); if (!addr) { return NULL; } addr->ops = ops; addr->location = location; addr->private_data = talloc_size(addr, psize); if (!addr->private_data) { talloc_free(addr); return NULL; } talloc_set_name_const(addr->private_data, type); *ppstate = addr->private_data; return addr; }
static NTSTATUS spoolss__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r) { enum ndr_err_code ndr_err; uint16_t opnum = dce_call->pkt.u.request.opnum; dce_call->fault_code = 0; if (opnum >= ndr_table_spoolss.num_calls) { dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR; return NT_STATUS_NET_WRITE_FAULT; } *r = talloc_size(mem_ctx, ndr_table_spoolss.calls[opnum].struct_size); NT_STATUS_HAVE_NO_MEMORY(*r); /* unravel the NDR for the packet */ ndr_err = ndr_table_spoolss.calls[opnum].ndr_pull(pull, NDR_IN, *r); if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { dcerpc_log_packet(dce_call->conn->packet_log_dir, &ndr_table_spoolss, opnum, NDR_IN, &dce_call->pkt.u.request.stub_and_verifier); dce_call->fault_code = DCERPC_FAULT_NDR; return NT_STATUS_NET_WRITE_FAULT; } return NT_STATUS_OK; }
/* test the SinkData interface */ static bool test_sinkdata(struct torture_context *tctx, struct dcerpc_pipe *p) { int i; NTSTATUS status; uint8_t *data_in; int len; struct echo_SinkData r; if (torture_setting_bool(tctx, "quick", false) && (p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) { len = 100 + (random() % 5000); } else { len = 200000 + (random() % 5000); } data_in = talloc_size(tctx, len); for (i=0;i<len;i++) { data_in[i] = i+1; } r.in.len = len; r.in.data = data_in; status = dcerpc_echo_SinkData(p, tctx, &r); torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx, "SinkData(%d) failed", len)); torture_comment(tctx, "sunk %d bytes\n", len); return true; }
struct tsocket_context *_tsocket_context_create(TALLOC_CTX *mem_ctx, const struct tsocket_context_ops *ops, void *pstate, size_t psize, const char *type, const char *location) { void **ppstate = (void **)pstate; struct tsocket_context *sock; sock = talloc_zero(mem_ctx, struct tsocket_context); if (!sock) { return NULL; } sock->ops = ops; sock->location = location; sock->private_data = talloc_size(sock, psize); if (!sock->private_data) { talloc_free(sock); return NULL; } talloc_set_name_const(sock->private_data, type); talloc_set_destructor(sock, tsocket_context_destructor); *ppstate = sock->private_data; return sock; }
static char * get_name_from_passwd_file (void *ctx) { long pw_buf_size; char *pw_buf; struct passwd passwd, *ignored; char *name; int e; pw_buf_size = sysconf(_SC_GETPW_R_SIZE_MAX); if (pw_buf_size == -1) pw_buf_size = 64; pw_buf = talloc_size (ctx, pw_buf_size); while ((e = getpwuid_r (getuid (), &passwd, pw_buf, pw_buf_size, &ignored)) == ERANGE) { pw_buf_size = pw_buf_size * 2; pw_buf = talloc_zero_size(ctx, pw_buf_size); } if (e == 0) { char *comma = strchr (passwd.pw_gecos, ','); if (comma) name = talloc_strndup (ctx, passwd.pw_gecos, comma - passwd.pw_gecos); else name = talloc_strdup (ctx, passwd.pw_gecos); } else { name = talloc_strdup (ctx, ""); } talloc_free (pw_buf); return name; }
/* * Store a record together with the ctdb record header * in the local copy of the database. */ static NTSTATUS db_ctdb_ltdb_store(struct db_ctdb_ctx *db, TDB_DATA key, struct ctdb_ltdb_header *header, TDB_DATA data) { TDB_DATA rec; int ret; rec.dsize = data.dsize + sizeof(struct ctdb_ltdb_header); rec.dptr = (uint8_t *)talloc_size(talloc_tos(), rec.dsize); if (rec.dptr == NULL) { return NT_STATUS_NO_MEMORY; } memcpy(rec.dptr, header, sizeof(struct ctdb_ltdb_header)); memcpy(sizeof(struct ctdb_ltdb_header) + (uint8_t *)rec.dptr, data.dptr, data.dsize); ret = tdb_store(db->wtdb->tdb, key, rec, TDB_REPLACE); talloc_free(rec.dptr); return (ret == 0) ? NT_STATUS_OK : tdb_error_to_ntstatus(db->wtdb->tdb); }
/* dump talloc memory hierarchy, returning it as a blob to the client */ int32_t ctdb_dump_memory(struct ctdb_context *ctdb, TDB_DATA *outdata) { /* dump to a file, then send the file as a blob */ FILE *f; long fsize; f = tmpfile(); if (f == NULL) { DEBUG(DEBUG_ERR,(__location__ " Unable to open tmpfile - %s\n", strerror(errno))); return -1; } talloc_report_full(NULL, f); fsize = ftell(f); if (fsize == -1) { DEBUG(DEBUG_ERR, (__location__ " Unable to get file size - %s\n", strerror(errno))); fclose(f); return -1; } rewind(f); outdata->dptr = talloc_size(outdata, fsize); if (outdata->dptr == NULL) { fclose(f); CTDB_NO_MEMORY(ctdb, outdata->dptr); } outdata->dsize = fread(outdata->dptr, 1, fsize, f); fclose(f); if (outdata->dsize != fsize) { DEBUG(DEBUG_ERR,(__location__ " Unable to read tmpfile\n")); return -1; } return 0; }
void *_policy_handle_create(struct pipes_struct *p, struct policy_handle *hnd, uint32_t access_granted, size_t data_size, const char *type, NTSTATUS *pstatus) { struct policy *pol; void *data; if (p->pipe_handles->count > MAX_OPEN_POLS) { DEBUG(0, ("policy_handle_create: ERROR: too many handles (%d) " "on pipe %s.\n", (int)p->pipe_handles->count, get_pipe_name_from_syntax(talloc_tos(), &p->syntax))); *pstatus = NT_STATUS_INSUFFICIENT_RESOURCES; return NULL; } data = talloc_size(talloc_tos(), data_size); if (data == NULL) { *pstatus = NT_STATUS_NO_MEMORY; return NULL; } talloc_set_name_const(data, type); pol = create_policy_hnd_internal(p, hnd, data); if (pol == NULL) { TALLOC_FREE(data); *pstatus = NT_STATUS_NO_MEMORY; return NULL; } pol->access_granted = access_granted; *pstatus = NT_STATUS_OK; return data; }
glsl_type::glsl_type(const glsl_type *array, unsigned length) : base_type(GLSL_TYPE_ARRAY), sampler_dimensionality(0), sampler_shadow(0), sampler_array(0), sampler_type(0), vector_elements(0), matrix_columns(0), name(NULL), length(length) { this->fields.array = array; /* Inherit the gl type of the base. The GL type is used for * uniform/statevar handling in Mesa and the arrayness of the type * is represented by the size rather than the type. */ this->gl_type = array->gl_type; /* Allow a maximum of 10 characters for the array size. This is enough * for 32-bits of ~0. The extra 3 are for the '[', ']', and terminating * NUL. */ const unsigned name_length = strlen(array->name) + 10 + 3; char *const n = (char *) talloc_size(this->mem_ctx, name_length); if (length == 0) snprintf(n, name_length, "%s[]", array->name); else snprintf(n, name_length, "%s[%u]", array->name, length); this->name = n; }
/* add an integer into a record in sorted order */ static int sort_func(struct ctdb_call_info *call) { if (call->call_data == NULL || call->call_data->dsize != sizeof(int)) { return CTDB_ERR_INVALID; } call->new_data = talloc(call, TDB_DATA); if (call->new_data == NULL) { return CTDB_ERR_NOMEM; } call->new_data->dptr = talloc_size(call, call->record_data.dsize + call->call_data->dsize); if (call->new_data->dptr == NULL) { return CTDB_ERR_NOMEM; } call->new_data->dsize = call->record_data.dsize + call->call_data->dsize; memcpy(call->new_data->dptr, call->record_data.dptr, call->record_data.dsize); memcpy(call->new_data->dptr+call->record_data.dsize, call->call_data->dptr, call->call_data->dsize); qsort(call->new_data->dptr, call->new_data->dsize / sizeof(int), sizeof(int), (comparison_fn_t)int_compare); return 0; }
static void append_route(struct radius_ctx_st *pctx, const char *route, unsigned len) { unsigned i; char *p; /* accept route/mask */ if ((p=strchr(route, '/')) == 0) return; p = strchr(p, ' '); if (p != NULL) { len = p - route; } if (pctx->routes_size == 0) { pctx->routes = talloc_size(pctx, sizeof(char*)); } else { pctx->routes = talloc_realloc_size(pctx, pctx->routes, (pctx->routes_size+1)*sizeof(char*)); } if (pctx->routes != NULL) { i = pctx->routes_size; pctx->routes[i] = talloc_strndup(pctx, route, len); if (pctx->routes[i] != NULL) pctx->routes_size++; } }
/* convert a dom_sid to a string */ char *dom_sid_string(TALLOC_CTX *mem_ctx, const struct dom_sid *sid) { int i, ofs, maxlen; uint32_t ia; char *ret; if (!sid) { return talloc_strdup(mem_ctx, "(NULL SID)"); } maxlen = sid->num_auths * 11 + 25; ret = (char *)talloc_size(mem_ctx, maxlen); if (!ret) return talloc_strdup(mem_ctx, "(SID ERR)"); ia = (sid->id_auth[5]) + (sid->id_auth[4] << 8 ) + (sid->id_auth[3] << 16) + (sid->id_auth[2] << 24); ofs = snprintf(ret, maxlen, "S-%u-%lu", (unsigned int)sid->sid_rev_num, (unsigned long)ia); for (i = 0; i < sid->num_auths; i++) { ofs += snprintf(ret + ofs, maxlen - ofs, "-%lu", (unsigned long)sid->sub_auths[i]); } return ret; }
int s3crypt_gen_salt(TALLOC_CTX *memctx, char **_salt) { uint8_t rb[SALT_RAND_LEN]; char *salt, *cp; size_t slen; int ret; ret = nspr_nss_init(); if (ret != EOK) { return EIO; } salt = talloc_size(memctx, SALT_LEN_MAX + 1); if (!salt) { return ENOMEM; } ret = PK11_GenerateRandom(rb, SALT_RAND_LEN); if (ret != SECSuccess) { return EIO; } slen = SALT_LEN_MAX; cp = salt; b64_from_24bit(&cp, &slen, 4, rb[0], rb[1], rb[2]); b64_from_24bit(&cp, &slen, 4, rb[3], rb[4], rb[5]); b64_from_24bit(&cp, &slen, 4, rb[6], rb[7], rb[8]); b64_from_24bit(&cp, &slen, 4, rb[9], rb[10], rb[11]); *cp = '\0'; *_salt = salt; return EOK; }
/* form a ctdb_rec_data record from a key/data pair note that header may be NULL. If not NULL then it is included in the data portion of the record */ static struct ctdb_rec_data *db_ctdb_marshall_record(TALLOC_CTX *mem_ctx, uint32_t reqid, TDB_DATA key, struct ctdb_ltdb_header *header, TDB_DATA data) { size_t length; struct ctdb_rec_data *d; length = offsetof(struct ctdb_rec_data, data) + key.dsize + data.dsize + (header?sizeof(*header):0); d = (struct ctdb_rec_data *)talloc_size(mem_ctx, length); if (d == NULL) { return NULL; } d->length = length; d->reqid = reqid; d->keylen = key.dsize; memcpy(&d->data[0], key.dptr, key.dsize); if (header) { d->datalen = data.dsize + sizeof(*header); memcpy(&d->data[key.dsize], header, sizeof(*header)); memcpy(&d->data[key.dsize+sizeof(*header)], data.dptr, data.dsize); } else { d->datalen = data.dsize; memcpy(&d->data[key.dsize], data.dptr, data.dsize); } return d; }
static bool test_pool(void) { void *pool; void *p1, *p2, *p3, *p4; pool = talloc_pool(NULL, 1024); p1 = talloc_size(pool, 80); p2 = talloc_size(pool, 20); p3 = talloc_size(p1, 50); p4 = talloc_size(p3, 1000); talloc_free(pool); return true; }
static enum NTDB_ERROR db_ntdb_fetchlock_parse(NTDB_DATA key, NTDB_DATA data, struct ntdb_fetch_locked_state *state) { struct db_record *result; result = (struct db_record *)talloc_size( state->mem_ctx, sizeof(struct db_record) + key.dsize + data.dsize); if (result == NULL) { return NTDB_ERR_OOM; } state->result = result; result->key.dsize = key.dsize; result->key.dptr = ((uint8_t *)result) + sizeof(struct db_record); memcpy(result->key.dptr, key.dptr, key.dsize); result->value.dsize = data.dsize; if (data.dsize > 0) { result->value.dptr = result->key.dptr+key.dsize; memcpy(result->value.dptr, data.dptr, data.dsize); } else { result->value.dptr = NULL; } return NTDB_SUCCESS; }
static int db_tdb_fetchlock_parse(TDB_DATA key, TDB_DATA data, void *private_data) { struct tdb_fetch_locked_state *state = (struct tdb_fetch_locked_state *)private_data; struct db_record *result; result = (struct db_record *)talloc_size( state->mem_ctx, sizeof(struct db_record) + key.dsize + data.dsize); if (result == NULL) { return 0; } state->result = result; result->key.dsize = key.dsize; result->key.dptr = ((uint8 *)result) + sizeof(struct db_record); memcpy(result->key.dptr, key.dptr, key.dsize); result->value.dsize = data.dsize; if (data.dsize > 0) { result->value.dptr = result->key.dptr+key.dsize; memcpy(result->value.dptr, data.dptr, data.dsize); } else { result->value.dptr = NULL; } return 0; }
static struct doc_section *new_section(struct list_head *list, const char *function, const char *type, unsigned int srcline) { struct doc_section *d; char *lowertype; unsigned int i; /* If previous section was empty, delete it. */ d = list_tail(list, struct doc_section, list); if (d && empty_section(d)) { list_del(&d->list); talloc_free(d); } d = talloc(list, struct doc_section); d->function = function; lowertype = talloc_size(d, strlen(type) + 1); /* Canonicalize type to lower case. */ for (i = 0; i < strlen(type)+1; i++) lowertype[i] = tolower(type[i]); d->type = lowertype; d->lines = NULL; d->num_lines = 0; d->srcline = srcline; list_add_tail(list, &d->list); return d; }
/* use ndr_print_* to convert a NDR formatted blob to a ldif formatted blob If mask_errors is true, then function succeeds but out data is set to "<Unable to decode binary data>" message \return 0 on success; -1 on error */ static int ldif_write_NDR(struct ldb_context *ldb, void *mem_ctx, const struct ldb_val *in, struct ldb_val *out, size_t struct_size, ndr_pull_flags_fn_t pull_fn, ndr_print_fn_t print_fn, bool mask_errors) { uint8_t *p; enum ndr_err_code err; if (!(ldb_get_flags(ldb) & LDB_FLG_SHOW_BINARY)) { return ldb_handler_copy(ldb, mem_ctx, in, out); } p = talloc_size(mem_ctx, struct_size); err = ndr_pull_struct_blob(in, mem_ctx, p, pull_fn); if (err != NDR_ERR_SUCCESS) { /* fail in not in mask_error mode */ if (!mask_errors) { return -1; } talloc_free(p); out->data = (uint8_t *)talloc_strdup(mem_ctx, "<Unable to decode binary data>"); out->length = strlen((const char *)out->data); return 0; } out->data = (uint8_t *)ndr_print_struct_string(mem_ctx, print_fn, "NDR", p); talloc_free(p); if (out->data == NULL) { return ldb_handler_copy(ldb, mem_ctx, in, out); } out->length = strlen((char *)out->data); return 0; }
void *_policy_handle_create(struct pipes_struct *p, struct policy_handle *hnd, uint32_t access_granted, size_t data_size, const char *type, NTSTATUS *pstatus) { struct dcesrv_handle *rpc_hnd; void *data; if (p->pipe_handles->count > MAX_OPEN_POLS) { DEBUG(0, ("ERROR: Too many handles (%d) for RPC connection %s\n", (int) p->pipe_handles->count, get_pipe_name_from_syntax(talloc_tos(), &p->contexts->syntax))); *pstatus = NT_STATUS_INSUFFICIENT_RESOURCES; return NULL; } data = talloc_size(talloc_tos(), data_size); if (data == NULL) { *pstatus = NT_STATUS_NO_MEMORY; return NULL; } talloc_set_name_const(data, type); rpc_hnd = create_rpc_handle_internal(p, hnd, data); if (rpc_hnd == NULL) { TALLOC_FREE(data); *pstatus = NT_STATUS_NO_MEMORY; return NULL; } rpc_hnd->access_granted = access_granted; *pstatus = NT_STATUS_OK; return data; }
static AudioChannelLayout* ca_query_layout(struct ao *ao, AudioDeviceID device, void *talloc_ctx) { OSStatus err; uint32_t psize; AudioChannelLayout *r = NULL; AudioObjectPropertyAddress p_addr = (AudioObjectPropertyAddress) { .mSelector = kAudioDevicePropertyPreferredChannelLayout, .mScope = kAudioDevicePropertyScopeOutput, .mElement = kAudioObjectPropertyElementWildcard, }; err = AudioObjectGetPropertyDataSize(device, &p_addr, 0, NULL, &psize); CHECK_CA_ERROR("could not get device preferred layout (size)"); r = talloc_size(talloc_ctx, psize); err = AudioObjectGetPropertyData(device, &p_addr, 0, NULL, &psize, r); CHECK_CA_ERROR("could not get device preferred layout (get)"); coreaudio_error: return r; }
/* measure the speed of talloc versus malloc */ static bool test_speed(void) { void *ctx = talloc_new(NULL); unsigned count; const int loop = 1000; int i; struct timeval tv; printf("test: speed [\nTALLOC VS MALLOC SPEED\n]\n"); tv = timeval_current(); count = 0; do { void *p1, *p2, *p3; for (i=0;i<loop;i++) { p1 = talloc_size(ctx, loop % 100); p2 = talloc_strdup(p1, "foo bar"); p3 = talloc_size(p1, 300); talloc_free(p1); } count += 3 * loop; } while (timeval_elapsed(&tv) < 5.0); fprintf(stderr, "talloc: %.0f ops/sec\n", count/timeval_elapsed(&tv)); talloc_free(ctx); tv = timeval_current(); count = 0; do { void *p1, *p2, *p3; for (i=0;i<loop;i++) { p1 = malloc(loop % 100); p2 = strdup("foo bar"); p3 = malloc(300); free(p1); free(p2); free(p3); } count += 3 * loop; } while (timeval_elapsed(&tv) < 5.0); fprintf(stderr, "malloc: %.0f ops/sec\n", count/timeval_elapsed(&tv)); printf("success: speed\n"); return true; }
static int get_pw_uid(TALLOC_CTX *mem_ctx, struct proxy_id_ctx *ctx, struct sysdb_ctx *sysdb, struct sss_domain_info *dom, uid_t uid) { TALLOC_CTX *tmpctx; struct passwd *pwd; enum nss_status status; char *buffer; size_t buflen; bool del_user = false; int ret; DEBUG(SSSDBG_TRACE_FUNC, ("Searching user by uid (%d)\n", uid)); tmpctx = talloc_new(NULL); if (!tmpctx) { return ENOMEM; } pwd = talloc_zero(tmpctx, struct passwd); if (!pwd) { ret = ENOMEM; goto done; } buflen = DEFAULT_BUFSIZE; buffer = talloc_size(tmpctx, buflen); if (!buffer) { ret = ENOMEM; goto done; } status = ctx->ops.getpwuid_r(uid, pwd, buffer, buflen, &ret); ret = handle_getpw_result(status, pwd, dom, &del_user); if (ret) { DEBUG(SSSDBG_OP_FAILURE, ("getpwuid failed [%d]: %s\n", ret, strerror(ret))); goto done; } if (del_user) { ret = delete_user(sysdb, dom, NULL, uid); goto done; } ret = save_user(sysdb, dom, !dom->case_sensitive, pwd, pwd->pw_name, NULL, dom->user_timeout); done: talloc_zfree(tmpctx); if (ret) { DEBUG(SSSDBG_CRIT_FAILURE, ("proxy -> getpwuid_r failed for '%d' <%d>: %s\n", uid, ret, strerror(ret))); } return ret; }
/* transport packet allocator - allows transport to control memory for packets */ static void *ctdb_tcp_allocate_pkt(TALLOC_CTX *mem_ctx, size_t size) { /* tcp transport needs to round to 8 byte alignment to ensure that we can use a length header and 64 bit elements in structures */ size = (size+(CTDB_TCP_ALIGNMENT-1)) & ~(CTDB_TCP_ALIGNMENT-1); return talloc_size(mem_ctx, size); }
static void initialise_output_state(TALLOC_CTX *mem_ctx, output_state *state, uint32_t rawSize, DATA_BLOB *output_blob) { state->out_pos = 0; state->out_size = rawSize + LZFU_HEADERLENGTH + 4; output_blob->data = (uint8_t *) talloc_size(mem_ctx, state->out_size); output_blob->length = 0; state->output_blob = output_blob; }
/* * This function is used to process data in queue buffer. * * Queue callback function can end up freeing the queue, there should not be a * loop processing packets from queue buffer. Instead set up a timed event for * immediate run to process remaining packets from buffer. */ static void queue_process(struct ctdb_queue *queue) { uint32_t pkt_size; uint8_t *data; if (queue->buffer.length < sizeof(pkt_size)) { return; } pkt_size = *(uint32_t *)queue->buffer.data; if (pkt_size == 0) { DEBUG(DEBUG_CRIT, ("Invalid packet of length 0\n")); goto failed; } if (queue->buffer.length < pkt_size) { if (pkt_size > QUEUE_BUFFER_SIZE) { queue->buffer.extend = pkt_size; } return; } /* Extract complete packet */ data = talloc_size(queue, pkt_size); if (data == NULL) { DEBUG(DEBUG_ERR, ("read error alloc failed for %u\n", pkt_size)); return; } memcpy(data, queue->buffer.data, pkt_size); /* Shift packet out from buffer */ if (queue->buffer.length > pkt_size) { memmove(queue->buffer.data, queue->buffer.data + pkt_size, queue->buffer.length - pkt_size); } queue->buffer.length -= pkt_size; if (queue->buffer.length > 0) { /* There is more data to be processed, schedule an event */ tevent_schedule_immediate(queue->im, queue->ctdb->ev, queue_process_event, queue); } else { if (queue->buffer.size > QUEUE_BUFFER_SIZE) { TALLOC_FREE(queue->buffer.data); queue->buffer.size = 0; } } /* It is the responsibility of the callback to free 'data' */ queue->callback(data, pkt_size, queue->private_data); return; failed: queue->callback(NULL, 0, queue->private_data); }
/* write a record to a normal database */ int ctdb_ltdb_store(struct ctdb_db_context *ctdb_db, TDB_DATA key, struct ctdb_ltdb_header *header, TDB_DATA data) { struct ctdb_context *ctdb = ctdb_db->ctdb; TDB_DATA rec; int ret; bool seqnum_suppressed = false; if (ctdb_db->ctdb_ltdb_store_fn) { return ctdb_db->ctdb_ltdb_store_fn(ctdb_db, key, header, data); } if (ctdb->flags & CTDB_FLAG_TORTURE) { struct ctdb_ltdb_header *h2; rec = tdb_fetch(ctdb_db->ltdb->tdb, key); h2 = (struct ctdb_ltdb_header *)rec.dptr; if (rec.dptr && rec.dsize >= sizeof(h2) && h2->rsn > header->rsn) { DEBUG(DEBUG_CRIT,("RSN regression! %llu %llu\n", (unsigned long long)h2->rsn, (unsigned long long)header->rsn)); } if (rec.dptr) free(rec.dptr); } rec.dsize = sizeof(*header) + data.dsize; rec.dptr = talloc_size(ctdb, rec.dsize); CTDB_NO_MEMORY(ctdb, rec.dptr); memcpy(rec.dptr, header, sizeof(*header)); memcpy(rec.dptr + sizeof(*header), data.dptr, data.dsize); /* Databases with seqnum updates enabled only get their seqnum changes when/if we modify the data */ if (ctdb_db->seqnum_update != NULL) { TDB_DATA old; old = tdb_fetch(ctdb_db->ltdb->tdb, key); if ( (old.dsize == rec.dsize) && !memcmp(old.dptr+sizeof(struct ctdb_ltdb_header), rec.dptr+sizeof(struct ctdb_ltdb_header), rec.dsize-sizeof(struct ctdb_ltdb_header)) ) { tdb_remove_flags(ctdb_db->ltdb->tdb, TDB_SEQNUM); seqnum_suppressed = true; } if (old.dptr) free(old.dptr); } ret = tdb_store(ctdb_db->ltdb->tdb, key, rec, TDB_REPLACE); if (ret != 0) { DEBUG(DEBUG_ERR, (__location__ " Failed to store dynamic data\n")); } if (seqnum_suppressed) { tdb_add_flags(ctdb_db->ltdb->tdb, TDB_SEQNUM); } talloc_free(rec.dptr); return ret; }
/* test the EchoData interface */ static bool test_echodata(struct torture_context *tctx, struct dcerpc_pipe *p) { int i; NTSTATUS status; uint8_t *data_in, *data_out; int len; struct echo_EchoData r; if (torture_setting_bool(tctx, "quick", false) && (p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) { len = 1 + (random() % 500); } else { len = 1 + (random() % 5000); } data_in = talloc_size(tctx, len); data_out = talloc_size(tctx, len); for (i=0;i<len;i++) { data_in[i] = i; } r.in.len = len; r.in.in_data = data_in; status = dcerpc_echo_EchoData(p, tctx, &r); torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx, "EchoData(%d) failed\n", len)); data_out = r.out.out_data; for (i=0;i<len;i++) { if (data_in[i] != data_out[i]) { torture_comment(tctx, "Bad data returned for len %d at offset %d\n", len, i); torture_comment(tctx, "in:\n"); dump_data(0, data_in+i, MIN(len-i, 16)); torture_comment(tctx, "out:\n"); dump_data(0, data_out+i, MIN(len-1, 16)); return false; } } return true; }