/** * \internal * Allocate a fs_name structure */ TSK_FS_NAME * tsk_fs_name_alloc(size_t norm_namelen, size_t shrt_namelen) { TSK_FS_NAME *fs_name; fs_name = (TSK_FS_NAME *) tsk_malloc(sizeof(*fs_name)); if (fs_name == NULL) return NULL; fs_name->name = (char *) tsk_malloc(norm_namelen + 1); if (fs_name->name == NULL) { free(fs_name); return NULL; } fs_name->name_size = norm_namelen; fs_name->flags = 0; fs_name->shrt_name_size = shrt_namelen; if (shrt_namelen == 0) { fs_name->shrt_name = NULL; } else { fs_name->shrt_name = (char *) tsk_malloc(shrt_namelen + 1); if (fs_name->shrt_name == NULL) { free(fs_name->name); free(fs_name); return NULL; } } fs_name->type = TSK_FS_NAME_TYPE_UNDEF; fs_name->tag = TSK_FS_NAME_TAG; return fs_name; }
/** \internal * Allocate a FS_DIR structure to load names into. * * @param a_addr Address of this directory. * @param a_cnt target number of FS_DENT entries to fit in * @returns NULL on error */ TSK_FS_DIR * tsk_fs_dir_alloc(TSK_FS_INFO * a_fs, TSK_INUM_T a_addr, size_t a_cnt) { TSK_FS_DIR *fs_dir; size_t i; // allocate and initialize the structure if ((fs_dir = (TSK_FS_DIR *) tsk_malloc(sizeof(TSK_FS_DIR))) == NULL) { return NULL; } fs_dir->names_alloc = a_cnt; fs_dir->names_used = 0; if ((fs_dir->names = (TSK_FS_NAME *) tsk_malloc(sizeof(TSK_FS_NAME) * fs_dir->names_alloc)) == NULL) { free(fs_dir); return NULL; } fs_dir->fs_info = a_fs; fs_dir->addr = a_addr; fs_dir->tag = TSK_FS_DIR_TAG; for (i = 0; i < a_cnt; i++) { fs_dir->names[i].tag = TSK_FS_NAME_TAG; } return fs_dir; }
/* Returns 0 on success and 1 on error */ uint8_t tsk_fs_fls(TSK_FS_INFO * fs, TSK_FS_FLS_FLAG_ENUM lclflags, TSK_INUM_T inode, TSK_FS_DIR_WALK_FLAG_ENUM flags, TSK_TCHAR * tpre, int32_t skew) { FLS_DATA data; data.flags = lclflags; data.sec_skew = skew; #ifdef TSK_WIN32 { size_t clen; UTF8 *ptr8; UTF16 *ptr16; int retval; if ((tpre != NULL) && (TSTRLEN(tpre) > 0)) { clen = TSTRLEN(tpre) * 4; data.macpre = (char *) tsk_malloc(clen); if (data.macpre == NULL) { return 1; } ptr8 = (UTF8 *) data.macpre; ptr16 = (UTF16 *) tpre; retval = tsk_UTF16toUTF8_lclorder((const UTF16 **) &ptr16, (UTF16 *) & ptr16[TSTRLEN(tpre) + 1], &ptr8, (UTF8 *) ((uintptr_t) ptr8 + clen), TSKlenientConversion); if (retval != TSKconversionOK) { tsk_error_reset(); tsk_error_set_errno(TSK_ERR_FS_UNICODE); tsk_error_set_errstr ("Error converting fls mactime pre-text to UTF-8 %d\n", retval); return 1; } } else { data.macpre = (char *) tsk_malloc(1); if (data.macpre == NULL) { return 1; } data.macpre[0] = '\0'; } retval = tsk_fs_dir_walk(fs, inode, flags, print_dent_act, &data); free(data.macpre); data.macpre = NULL; return retval; } #else data.macpre = tpre; return tsk_fs_dir_walk(fs, inode, flags, print_dent_act, &data); #endif }
/** * Identify regions in the partition list where there are unused sectors * and create new entries for them. * * @param a_vs Pointer to open volume system * @returns 1 on error and 0 on success */ uint8_t tsk_vs_part_unused(TSK_VS_INFO * a_vs) { TSK_VS_PART_INFO *part = a_vs->part_list; TSK_DADDR_T prev_end = 0; /* prev_ent is set to where the previous entry stopped plus 1 */ for (part = a_vs->part_list; part != NULL; part = part->next) { // ignore the META volume if (part->flags & TSK_VS_PART_FLAG_META) continue; // there is space before current and previous volume if (part->start > prev_end) { char *str; if ((str = tsk_malloc(12)) == NULL) return 1; snprintf(str, 12, "Unallocated"); if (NULL == tsk_vs_part_add(a_vs, prev_end, part->start - prev_end, TSK_VS_PART_FLAG_UNALLOC, str, -1, -1)) { free(str); return 1; } } prev_end = part->start + part->len; } /* Is there unallocated space at the end? */ if (prev_end < (TSK_DADDR_T) (a_vs->img_info->size / a_vs->block_size)) { char *str; if ((str = tsk_malloc(12)) == NULL) return 1; snprintf(str, 12, "Unallocated"); if (NULL == tsk_vs_part_add(a_vs, prev_end, a_vs->img_info->size / a_vs->block_size - prev_end, TSK_VS_PART_FLAG_UNALLOC, str, -1, -1)) { free(str); return 1; } } return 0; }
/* * Convert the record file name from UTF16 to UTF8. * Returns 0 on success, 1 otherwise */ static uint8_t parse_fname(const unsigned char *buf, uint16_t nlen, TSK_USN_RECORD_V2 *record, TSK_ENDIAN_ENUM endian) { int ret = 0; UTF8 *temp_name = NULL; size_t src_len = (size_t) nlen, dst_len = (size_t) nlen * 2; record->fname = tsk_malloc(dst_len + 1); if (record->fname == NULL) return 1; temp_name = (UTF8*)record->fname; ret = tsk_UTF16toUTF8(endian, (const UTF16**)&buf, (UTF16*)&buf[src_len], (UTF8**)&temp_name, (UTF8*)&temp_name[dst_len], TSKlenientConversion); if (ret != TSKconversionOK) { if (tsk_verbose) tsk_fprintf( stderr, "parse_v2_record: USN name to UTF8 conversion error."); record->fname = '\0'; } else record->fname[dst_len] = '\0'; return 0; }
/** * Walk through the Update Sequence Number journal file * opened with ntfs_usnjopen. * * For each USN record, calls the callback action passing the USN record header, * the USN record and the pointer ptr. * * @param ntfs File system where the journal is stored * @param action action to be called per each USN entry * @param ptr pointer to data passed to the action callback * @returns 0 on success, 1 otherwise */ uint8_t tsk_ntfs_usnjentry_walk(TSK_FS_INFO *fs, TSK_FS_USNJENTRY_WALK_CB action, void *ptr) { uint8_t ret = 0; unsigned char *buf = NULL; NTFS_INFO *ntfs = (NTFS_INFO*)fs; tsk_error_reset(); if (ntfs == NULL || ntfs->fs_info.ftype != TSK_FS_TYPE_NTFS) { tsk_error_set_errno(TSK_ERR_FS_ARG); tsk_error_set_errstr("Invalid FS type in ntfs_usnjentry_walk"); return 1; } if (ntfs->usnjinfo == NULL) { tsk_error_set_errno(TSK_ERR_FS_ARG); tsk_error_set_errstr("Must call tsk_ntfs_usnjopen first"); return 1; } buf = tsk_malloc(ntfs->usnjinfo->bsize); if (buf == NULL) return 1; ret = parse_file(ntfs, buf, action, ptr); tsk_fs_file_close(ntfs->usnjinfo->fs_file); free(ntfs->usnjinfo); free(buf); return ret; }
JNIEXPORT jbyteArray JNICALL Java_org_sleuthkit_datamodel_SleuthkitJNI_readVolNat(JNIEnv * env, jclass obj, jlong a_vol_info, jlong offset, jlong len) { char *buf = (char *) tsk_malloc((size_t) len); if (buf == NULL) { throwTskError(env); return NULL; } TSK_VS_PART_INFO *vol_part_info = castVsPartInfo(env, a_vol_info); ssize_t retval = tsk_vs_part_read(vol_part_info, (TSK_OFF_T) offset, buf, (size_t) len); if (retval == -1) { throwTskError(env, tsk_error_get()); free(buf); return NULL; } // package it up for return jbyteArray return_array = copyBufToByteArray(env, buf, retval); // no point checking for error. copyBufToByteArray will call throwTskError and return NULL itself free(buf); return return_array; }
/** * Load the contents of a file into a buffer. * * @param fs The file system structure. * @param fsi The inode structure of the file to read. * @param type The type of attribute to load (ignored if TSK_FS_FILE_FLAG_NOID is given) * @param id The id of attribute to load (ignored if TSK_FS_FILE_FLAG_NOID is given) * @param flags Flag values of type TSK_FS_FILE_FLAG_* * @return The buffer with the file content (must be freed by caller) */ char * tsk_fs_load_file(TSK_FS_INFO * fs, TSK_FS_INODE * fsi, uint32_t type, uint16_t id, int flags) { TSK_FS_LOAD_FILE lf; if (NULL == (lf.base = (char *) tsk_malloc((size_t) fsi->size))) { return NULL; } lf.left = lf.total = (size_t) fsi->size; lf.cur = lf.base; if (fs->file_walk(fs, fsi, type, id, flags, fs_load_file_act, (void *) &lf)) { free(lf.base); strncat(tsk_errstr2, " - tsk_fs_load_file", TSK_ERRSTR_L - strlen(tsk_errstr2)); return NULL; } /* Not all of the file was copied */ if (lf.left > 0) { tsk_error_reset(); tsk_errno = TSK_ERR_FS_FWALK; snprintf(tsk_errstr, TSK_ERRSTR_L, "tsk_fs_load_file: Error reading file %" PRIuINUM, fsi->addr); free(lf.base); return NULL; } return lf.base; }
static int _v4l2_init_read(tdav_producer_video_v4l2_t* p_self, unsigned int buffer_size) { if (p_self->p_buffers) { V4L2_DEBUG_ERROR("Buffers already initialized"); return -1; } if (!buffer_size) { V4L2_DEBUG_ERROR("Invalid parameter"); return -1; } if (!(p_self->p_buffers = calloc(1, sizeof(*p_self->p_buffers)))) { V4L2_DEBUG_ERROR("Out of memory"); return -1; } p_self->p_buffers[0].n_length = buffer_size; p_self->p_buffers[0].p_start = tsk_malloc(buffer_size); if (!p_self->p_buffers[0].p_start) { V4L2_DEBUG_ERROR("Out of memory"); return -1; } return 0; }
/** * \ingroup baselib * Create a TSK_STACK structure * @returns Pointer to structure or NULL on error */ TSK_STACK * tsk_stack_create() { TSK_STACK *tsk_stack; if ((tsk_stack = (TSK_STACK *) tsk_malloc(sizeof(TSK_STACK))) == NULL) { return NULL; } tsk_stack->len = 64; tsk_stack->top = 0; if ((tsk_stack->vals = (uint64_t *) tsk_malloc(tsk_stack->len * sizeof(uint64_t))) == NULL) { free(tsk_stack); return NULL; } return tsk_stack; }
/** * \internal * Allocate a run list entry. * * @returns NULL on error */ TSK_FS_ATTR_RUN * tsk_fs_attr_run_alloc() { TSK_FS_ATTR_RUN *fs_attr_run = (TSK_FS_ATTR_RUN *) tsk_malloc(sizeof(TSK_FS_ATTR_RUN)); if (fs_attr_run == NULL) return NULL; return fs_attr_run; }
/** \internal * Allocate a new map entry with a default address buffer. * @returns NULL on error */ static NTFS_PAR_MAP * ntfs_orphan_map_alloc() { NTFS_PAR_MAP *map; if ((map = (NTFS_PAR_MAP *) tsk_malloc((size_t) sizeof(NTFS_PAR_MAP))) == NULL) { return NULL; } map->alloc_cnt = 8; if ((map->addrs = (TSK_INUM_T *) tsk_malloc(sizeof(TSK_INUM_T) * map->alloc_cnt)) == NULL) { free(map); return NULL; } return map; }
/** \internal * Allocate a new data list structure * * @returns Pointer to new list structure or NULL on error */ TSK_FS_ATTRLIST * tsk_fs_attrlist_alloc() { TSK_FS_ATTRLIST *fs_attrlist; if ((fs_attrlist = (TSK_FS_ATTRLIST *) tsk_malloc(sizeof(TSK_FS_ATTRLIST))) == NULL) return NULL; return fs_attrlist; }
/* tsk_img_malloc - init lock after tsk_malloc * This is for img module and all its inheritances */ void * tsk_img_malloc(size_t a_len) { TSK_IMG_INFO *imgInfo; if ((imgInfo = (TSK_IMG_INFO *) tsk_malloc(a_len)) == NULL) return NULL; //init lock tsk_init_lock(&(imgInfo->cache_lock)); imgInfo->tag = TSK_IMG_INFO_TAG; return (void *) imgInfo; }
/** * \internal * Allocate a TSK_FS_BLOCK structure. * @param a_fs File system to create block for * @returns NULL on error */ TSK_FS_BLOCK * tsk_fs_block_alloc(TSK_FS_INFO * a_fs) { TSK_FS_BLOCK *fs_block; fs_block = (TSK_FS_BLOCK *) tsk_malloc(sizeof(TSK_FS_BLOCK)); if (fs_block == NULL) return NULL; fs_block->buf = (char *) tsk_malloc(a_fs->block_size); if (fs_block->buf == NULL) { free(fs_block); return NULL; } fs_block->tag = TSK_FS_BLOCK_TAG; fs_block->addr = 0; fs_block->flags = 0; fs_block->fs_info = a_fs; return fs_block; }
/** * \internal * Allocate a new FS_FILE structure * @param a_fs File system fiel will be in. * @returns NULL on error */ TSK_FS_FILE * tsk_fs_file_alloc(TSK_FS_INFO * a_fs) { TSK_FS_FILE *fs_file; fs_file = (TSK_FS_FILE *) tsk_malloc(sizeof(TSK_FS_FILE)); if (fs_file == NULL) return NULL; fs_file->fs_info = a_fs; fs_file->tag = TSK_FS_FILE_TAG; return fs_file; }
/* rawfs_open - open a file as raw * * Return NULL on error * */ TSK_FS_INFO * rawfs_open(TSK_IMG_INFO * img_info, SSIZE_T offset) { OFF_T len; TSK_FS_INFO *fs; // clean up any error messages that are lying around tsk_error_reset(); fs = (TSK_FS_INFO *) tsk_malloc(sizeof(TSK_FS_INFO)); if (fs == NULL) return NULL; /* All we need to set are the block sizes and max block size etc. */ fs->img_info = img_info; fs->offset = offset; fs->ftype = TSK_FS_INFO_TYPE_RAW; fs->duname = "Sector"; fs->flags = 0; fs->inum_count = 0; fs->root_inum = 0; fs->first_inum = 0; fs->last_inum = 0; len = img_info->get_size(img_info); fs->block_count = len / 512; if (len % 512) fs->block_count++; fs->first_block = 0; fs->last_block = fs->block_count - 1; fs->block_size = 512; fs->dev_bsize = 512; fs->inode_walk = rawfs_inode_walk; fs->block_walk = rawfs_block_walk; fs->inode_lookup = rawfs_inode_lookup; fs->dent_walk = rawfs_dent_walk; fs->file_walk = rawfs_file_walk; fs->fsstat = rawfs_fsstat; fs->istat = rawfs_istat; fs->close = rawfs_close; fs->jblk_walk = rawfs_jblk_walk; fs->jentry_walk = rawfs_jentry_walk; fs->jopen = rawfs_jopen; fs->journ_inum = 0; return (fs); }
/* tsk_fs_malloc - init lock after tsk_malloc * This is for fs module and all it's inheritances */ TSK_FS_INFO * tsk_fs_malloc(size_t a_len) { TSK_FS_INFO *fs_info; if ((fs_info = (TSK_FS_INFO *) tsk_malloc(a_len)) == NULL) return NULL; tsk_init_lock(&fs_info->list_inum_named_lock); tsk_init_lock(&fs_info->orphan_dir_lock); fs_info->list_inum_named = NULL; return fs_info; }
/** * \internal * Allocates a generic inode / metadata structure. * * @param a_buf_len Number of bytes needed to store fs-specific data regarding where content is stored. * @returns NULL on error */ TSK_FS_META * tsk_fs_meta_alloc(size_t a_buf_len) { TSK_FS_META *fs_meta; if ((fs_meta = (TSK_FS_META *) tsk_malloc(sizeof(TSK_FS_META))) == NULL) return NULL; fs_meta->attr_state = TSK_FS_META_ATTR_EMPTY; if (a_buf_len > 0) { if ((fs_meta->content_ptr = tsk_malloc(a_buf_len)) == NULL) { free(fs_meta); return NULL; } fs_meta->content_len = a_buf_len; } // assign the id so we know the structure is still alloc fs_meta->tag = TSK_FS_META_TAG; return (fs_meta); }
/** * \internal * Allocates and initializes a new structure. * * @param type The type of attribute to create (Resident or Non-resident) * @returns NULL on error */ TSK_FS_ATTR * tsk_fs_attr_alloc(TSK_FS_ATTR_FLAG_ENUM type) { TSK_FS_ATTR *fs_attr = (TSK_FS_ATTR *) tsk_malloc(sizeof(TSK_FS_ATTR)); if (fs_attr == NULL) { return NULL; } fs_attr->name_size = 128; if ((fs_attr->name = (char *) tsk_malloc(fs_attr->name_size)) == NULL) { free(fs_attr); return NULL; } if (type == TSK_FS_ATTR_NONRES) { fs_attr->flags = (TSK_FS_ATTR_NONRES | TSK_FS_ATTR_INUSE); } else if (type == TSK_FS_ATTR_RES) { fs_attr->rd.buf_size = 1024; fs_attr->rd.buf = (uint8_t *) tsk_malloc(fs_attr->rd.buf_size); if (fs_attr->rd.buf == NULL) { free(fs_attr->name); return NULL; } fs_attr->flags = (TSK_FS_ATTR_RES | TSK_FS_ATTR_INUSE); } else { tsk_error_reset(); tsk_error_set_errno(TSK_ERR_FS_ARG); tsk_error_set_errstr("tsk_fs_attr_alloc: Invalid Type: %d\n", type); return NULL; } return fs_attr; }
/* convert HFS+'s UTF16 to UTF8 * replaces null characters with another character (0xfffd) * replaces slashes (permitted by HFS+ but causes problems with TSK) * with colons (generally not allowed by Mac OS X) * note that at least one directory on HFS+ volumes begins with * four nulls, so we do need to handle nulls; also, Apple chooses * to encode nulls as UTF8 \xC0\x80, which is not a valid UTF8 sequence * returns 0 on success, 1 on failure; sets up to error string 1 */ uint8_t hfs_uni2ascii(TSK_FS_INFO * fs, uint8_t * uni, int ulen, char *asc, int alen) { char *aptr; uint8_t *uniclean; uint8_t *uptr; int i; TSKConversionResult r; // remove nulls from the Unicode string // convert / to : uniclean = (uint8_t *) tsk_malloc(ulen * 2); memcpy(uniclean, uni, ulen * 2); for (i = 0; i < ulen; ++i) { uint16_t uc = tsk_getu16(fs->endian, uniclean + i * 2); int changed = 0; if (uc == UTF16_NULL) { uc = UTF16_NULL_REPLACE; changed = 1; } else if (uc == UTF16_SLASH) { uc = UTF16_COLON; changed = 1; } if (changed) *((uint16_t *) (uniclean + i * 2)) = tsk_getu16(fs->endian, (uint8_t *) & uc); } memset(asc, 0, alen); aptr = asc; uptr = uniclean; r = tsk_UTF16toUTF8(fs->endian, (const UTF16 **) &uptr, (const UTF16 *) (uptr + ulen * 2), (UTF8 **) & aptr, (UTF8 *) aptr + alen - 1, TSKstrictConversion); if (r != TSKconversionOK) { tsk_errno = TSK_ERR_FS_UNICODE; snprintf(tsk_errstr, TSK_ERRSTR_L, "hfs_uni2ascii: unicode conversion failed (%d)", (int)r); free(uniclean); return 1; } free(uniclean); return 0; }
/* * Return a buffer with a description of the partition type */ static char * sun_get_desc(uint16_t fstype) { char *str = tsk_malloc(64); if (str == NULL) return ""; switch (fstype) { case 0: strncpy(str, "Unassigned (0x00)", 64); break; case 1: strncpy(str, "boot (0x01)", 64); break; case 2: strncpy(str, "/ (0x02)", 64); break; case 3: strncpy(str, "swap (0x03)", 64); break; case 4: strncpy(str, "/usr/ (0x04)", 64); break; case 5: strncpy(str, "backup (0x05)", 64); break; case 6: strncpy(str, "stand (0x06)", 64); break; case 7: strncpy(str, "/var/ (0x07)", 64); break; case 8: strncpy(str, "/home/ (0x08)", 64); break; case 9: strncpy(str, "alt sector (0x09)", 64); break; case 10: strncpy(str, "cachefs (0x0A)", 64); break; default: snprintf(str, 64, "Unknown Type (0x%.4x)", fstype); break; } return str; }
/* Place journal data in *fs * * Return 0 on success and 1 on error * */ uint8_t ext2fs_jopen(TSK_FS_INFO * fs, TSK_INUM_T inum) { EXT2FS_INFO *ext2fs = (EXT2FS_INFO *) fs; EXT2FS_JINFO *jinfo; // clean up any error messages that are lying around tsk_error_reset(); if (!fs) { tsk_error_reset(); tsk_errno = TSK_ERR_FS_ARG; snprintf(tsk_errstr, TSK_ERRSTR_L, "ext2fs_jopen: fs is null"); return 1; } ext2fs->jinfo = jinfo = (EXT2FS_JINFO *) tsk_malloc(sizeof(EXT2FS_JINFO)); if (jinfo == NULL) { return 1; } jinfo->j_inum = inum; jinfo->fs_file = tsk_fs_file_open_meta(fs, NULL, inum); if (!jinfo->fs_file) { free(jinfo); return 1; // error("error finding journal inode %" PRIu32, inum); } if (tsk_fs_file_walk(jinfo->fs_file, 0, load_sb_action, NULL)) { tsk_error_reset(); tsk_errno = TSK_ERR_FS_FWALK; snprintf(tsk_errstr, TSK_ERRSTR_L, "Error loading ext3 journal"); tsk_fs_file_close(jinfo->fs_file); free(jinfo); return 1; } if (tsk_verbose) tsk_fprintf(stderr, "journal opened at inode %" PRIuINUM " bsize: %" PRIu32 " First JBlk: %" PRIuDADDR " Last JBlk: %" PRIuDADDR "\n", inum, jinfo->bsize, jinfo->first_block, jinfo->last_block); return 0; }
/**@ingroup tsk_url_group * Encode an url. * @param url The url to encode * @retval The encoded url. It is up to you to free the returned string. * * @sa tsk_url_decode * */ char* tsk_url_encode(const char* url) { char *purl = (char*)url, *buf = tsk_malloc(tsk_strlen(url) * 3 + 1), *pbuf = buf; while (*purl) { if (isalnum(*purl) || *purl == '-' || *purl == '_' || *purl == '.' || *purl == '~'){ *pbuf++ = *purl; } else if (*purl == ' '){ *pbuf++ = '+'; } else{ *pbuf++ = '%', *pbuf++ = tsk_b10tob16(*purl >> 4), *pbuf++ = tsk_b10tob16(*purl & 15); } purl++; } *pbuf = '\0'; return buf; }
static int _tnet_transport_dtls_cb(const void* usrdata, tnet_dtls_socket_event_type_t dtls_e, const tnet_dtls_socket_handle_t* handle, const void* data, tsk_size_t size) { tnet_transport_t *transport = (tnet_transport_t*)usrdata; if (transport) { tnet_transport_event_type_t t_e; const struct sockaddr_storage* remote_addr; tnet_fd_t fd; tnet_transport_event_t* e; switch (dtls_e) { case tnet_dtls_socket_event_type_handshake_started: t_e = event_dtls_handshake_started; break; case tnet_dtls_socket_event_type_handshake_succeed: t_e = event_dtls_handshake_succeed; break; case tnet_dtls_socket_event_type_handshake_failed: t_e = event_dtls_handshake_failed; break; case tnet_dtls_socket_event_type_fingerprint_mismatch: t_e = event_dtls_fingerprint_mismatch; break; case tnet_dtls_socket_event_type_dtls_srtp_profile_selected: t_e = event_dtls_srtp_profile_selected; break; case tnet_dtls_socket_event_type_dtls_srtp_data: t_e = event_dtls_srtp_data; break; case tnet_dtls_socket_event_type_error: t_e = event_dtls_error; break; default: TSK_DEBUG_ERROR("DTLS event = %d ignored", dtls_e); return -1; } remote_addr = tnet_dtls_socket_get_remote_addr(handle); fd = tnet_dtls_socket_get_fd(handle); if ((e = tnet_transport_event_create(t_e, transport->callback_data, fd))) { if (data && size && (e ->data = tsk_malloc(size))) { memcpy(e ->data, data, size); e->size = size; } if (remote_addr) { e->remote_addr = *remote_addr; } if (TSK_RUNNABLE(transport)->initialized && TSK_RUNNABLE(transport)->running && TSK_RUNNABLE(transport)->started) { TSK_RUNNABLE_ENQUEUE_OBJECT_SAFE(TSK_RUNNABLE(transport), e); } else { TSK_DEBUG_INFO("Delivering network event synchronously."); // network transport not started (happens when TURN is using the sockets instead of the RTP manager) if (transport->callback) { transport->callback(e); } TSK_OBJECT_SAFE_FREE(e); } return 0; } } return -1; }
/**@ingroup tsk_url_group * Decode an url. * @param url The url to encode * @retval The decoded url. It is up to you to free the returned string. * * @sa tsk_url_encode */ char* tsk_url_decode(const char* url) { char *purl = (char*)url, *buf = tsk_malloc(tsk_strlen(url) + 1), *pbuf = buf; while (*purl) { if (*purl == '%') { if (purl[1] && purl[2]) { *pbuf++ = tsk_b16tob10(purl[1]) << 4 | tsk_b16tob10(purl[2]); purl += 2; } } else if (*purl == '+') { *pbuf++ = ' '; } else { *pbuf++ = *purl; } purl++; } *pbuf = '\0'; return buf; }
TSK_MM_INFO * tsk_mm_gpt_open(TSK_IMG_INFO * img_info, DADDR_T offset) { TSK_MM_INFO *mm; // clean up any errors that are lying around tsk_error_reset(); mm = (TSK_MM_INFO *) tsk_malloc(sizeof(*mm)); if (mm == NULL) return NULL; mm->img_info = img_info; mm->mmtype = TSK_MM_INFO_TYPE_GPT; mm->str_type = "GUID Partition Table"; /* If an offset was given, then use that too */ mm->offset = offset; /* inititialize settings */ mm->part_list = NULL; mm->first_part = mm->last_part = 0; mm->endian = 0; mm->dev_bsize = 512; mm->block_size = 512; /* Assign functions */ mm->part_walk = gpt_part_walk; mm->close = gpt_close; /* Load the partitions into the sorted list */ if (gpt_load_table(mm)) { gpt_close(mm); return NULL; } /* fill in the sorted list with the 'unknown' values */ if (tsk_mm_part_unused(mm)) { gpt_close(mm); return NULL; } return mm; }
/**@ingroup tsk_string_group */ void tsk_strncat(char** destination, const char* source, tsk_size_t n) { tsk_size_t index = 0; tsk_size_t tsk_size_to_cat = (n > tsk_strlen(source)) ? tsk_strlen(source) : n; if(!source || !n){ return; } if(!*destination){ *destination = (char*)tsk_malloc(tsk_size_to_cat+1); strncpy(*destination, source, tsk_size_to_cat+1); }else{ index = tsk_strlen(*destination); *destination = tsk_realloc(*destination, index + tsk_size_to_cat+1); strncpy(((*destination)+index), source, tsk_size_to_cat+1); } (*destination)[index + tsk_size_to_cat] = '\0'; }
TSK_VS_INFO * tsk_vs_sun_open(TSK_IMG_INFO * img_info, TSK_DADDR_T offset) { TSK_VS_INFO *vs; // clean up any errors that are lying around tsk_error_reset(); vs = (TSK_VS_INFO *) tsk_malloc(sizeof(*vs)); if (vs == NULL) return NULL; vs->img_info = img_info; vs->vstype = TSK_VS_TYPE_SUN; vs->tag = TSK_VS_INFO_TAG; vs->offset = offset; /* inititialize settings */ vs->part_list = NULL; vs->part_count = 0; vs->endian = 0; vs->block_size = img_info->sector_size; /* Assign functions */ vs->close = sun_close; /* Load the partitions into the sorted list */ if (sun_load_table(vs)) { sun_close(vs); return NULL; } /* fill in the sorted list with the 'unknown' values */ if (tsk_vs_part_unused(vs)) { sun_close(vs); return NULL; } return vs; }
static int tsk_printf_conv(WCHAR * wbuf, int wlen, const char *msg, va_list * args) { char *cbuf; UTF8 *ptr8; UTF16 *ptr16; int retVal; size_t len, clen; wbuf[0] = '\0'; /* Allocate a UTF-8 buffer and process the printf args */ clen = wlen * 3; if (NULL == (cbuf = (char *) tsk_malloc(clen))) { return 1; } memset(cbuf, 0, clen); #ifdef _MSC_VER vsnprintf_s(cbuf, clen - 1, _TRUNCATE, msg, *args); #else vsnprintf(cbuf, clen - 1, msg, *args); #endif len = strlen(cbuf); //Convert to UTF-16 ptr8 = (UTF8 *) cbuf; ptr16 = (UTF16 *) wbuf; retVal = tsk_UTF8toUTF16((const UTF8 **) &ptr8, &ptr8[len + 1], &ptr16, &ptr16[wlen], TSKlenientConversion); if (retVal != TSKconversionOK) { *ptr16 = '\0'; if (tsk_verbose) tsk_fprintf(stderr, "tsk_printf_conv: error converting string to UTF-16\n"); } free(cbuf); return 0; }