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

/** * /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_ttsk_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_ttsk_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_tparse_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_ttsk_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 JNICALLJava_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_thfs_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_text2fs_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 inttsk_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;}