/**
* \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;
}
