Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 2001 - 2004 Pekka Riikonen
+ Copyright (C) 2001 - 2008 Pekka Riikonen
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/* $Id$ */
/* XXX TODO Win32 support */
-#include "silcincludes.h"
+#include "silc.h"
#include "silcsftp.h"
#include "silcsftp_fs.h"
#include "sftp_util.h"
/* Generates absolute path from relative path that may include '.' and '..'
in the path. */
-static char *mem_expand_path(MemFSEntry root, const char *path)
+static char *memfs_expand_path(MemFSEntry root, const char *path)
{
if (!strstr(path, "./") && !strstr(path, "../") &&
!strstr(path, "/..") && !strstr(path, "/."))
/* Add `entry' to directory `dir'. */
-static bool mem_add_entry(MemFSEntry dir, MemFSEntry entry,
- bool check_perm)
+static SilcBool memfs_add_entry(MemFSEntry dir, MemFSEntry entry,
+ SilcBool check_perm)
{
int i;
/* Removes entry `entry' and all entries under it recursively. */
-static bool mem_del_entry(MemFSEntry entry, bool check_perm)
+static SilcBool memfs_del_entry(MemFSEntry entry, SilcBool check_perm)
{
int i;
/* Delete all entries recursively under this entry */
for (i = 0; i < entry->entry_count; i++) {
if (entry->entry[i]) {
- if (!mem_del_entry(entry->entry[i], FALSE))
+ if (!memfs_del_entry(entry->entry[i], FALSE))
return FALSE;
}
}
/* Finds first occurence of entry named `name' under the directory `dir'.
This does not check subdirectories recursively. */
-static MemFSEntry mem_find_entry(MemFSEntry dir, const char *name,
- SilcUInt32 name_len)
+static MemFSEntry memfs_find_entry(MemFSEntry dir, const char *name,
+ SilcUInt32 name_len)
{
int i;
/* Finds the entry by the `path' which may include full path or
relative path. */
-static MemFSEntry mem_find_entry_path(MemFSEntry dir, const char *p)
+static MemFSEntry memfs_find_entry_path(MemFSEntry dir, const char *p)
{
MemFSEntry entry = NULL;
int len;
char *path, *cp;
- cp = path = mem_expand_path(dir, p);
+ cp = path = memfs_expand_path(dir, p);
if (strlen(cp) == 1 && cp[0] == '/')
return dir;
cp++;
len = strcspn(cp, DIR_SEPARATOR);
while (cp && len) {
- entry = mem_find_entry(dir, cp, len);
+ entry = memfs_find_entry(dir, cp, len);
if (!entry) {
silc_free(cp);
return NULL;
/* Deletes entry by the name `name' from the directory `dir'. This does
not check subdirectories recursively. */
-static bool mem_del_entry_name(MemFSEntry dir, const char *name,
- SilcUInt32 name_len, bool check_perm)
+static SilcBool memfs_del_entry_name(MemFSEntry dir, const char *name,
+ SilcUInt32 name_len, SilcBool check_perm)
{
MemFSEntry entry;
if (check_perm)
return FALSE;
- entry = mem_find_entry(dir, name, name_len);
+ entry = memfs_find_entry(dir, name, name_len);
if (entry)
- return mem_del_entry(entry, check_perm);
+ return memfs_del_entry(entry, check_perm);
return FALSE;
}
/* Create new handle and add it to the list of open handles. */
-static MemFSFileHandle mem_create_handle(MemFS fs, int fd, MemFSEntry entry)
+static MemFSFileHandle memfs_create_handle(MemFS fs, int fd, MemFSEntry entry)
{
MemFSFileHandle handle;
int i;
/* Deletes the handle and remove it from the open handle list. */
-static bool mem_del_handle(MemFS fs, MemFSFileHandle handle)
+static SilcBool memfs_del_handle(MemFS fs, MemFSFileHandle handle)
{
if (handle->handle > fs->handles_count)
return FALSE;
/* Find handle by handle index. */
-static MemFSFileHandle mem_find_handle(MemFS fs, SilcUInt32 handle)
+static MemFSFileHandle memfs_find_handle(MemFS fs, SilcUInt32 handle)
{
if (handle > fs->handles_count)
return NULL;
fs->root_perm = perm;
fs->root->directory = TRUE;
fs->root->name = strdup(DIR_SEPARATOR);
+ if (!fs->root->name) {
+ silc_free(fs->root);
+ silc_free(fs);
+ }
filesystem = silc_calloc(1, sizeof(*filesystem));
if (!filesystem) {
+ silc_free(fs->root->name);
silc_free(fs->root);
silc_free(fs);
return NULL;
return NULL;
entry->perm = perm;
- entry->name = strdup(name);
entry->directory = TRUE;
entry->parent = dir ? dir : memfs->root;
+ entry->name = strdup(name);
+ if (!entry->name) {
+ silc_free(entry);
+ return NULL;
+ }
- if (!mem_add_entry(dir ? dir : memfs->root, entry, FALSE))
+ if (!memfs_add_entry(dir ? dir : memfs->root, entry, FALSE)) {
+ silc_free(entry->name);
+ silc_free(entry);
return NULL;
+ }
return entry;
}
in memory file system. The filesystem does not allow removing directories
with remote access using the filesystem access function sftp_rmdir. */
-bool silc_sftp_fs_memory_del_dir(SilcSFTPFilesystem fs, void *dir)
+SilcBool silc_sftp_fs_memory_del_dir(SilcSFTPFilesystem fs, void *dir)
{
MemFS memfs = (MemFS)fs->fs_context;
- bool ret;
+ SilcBool ret;
if (dir)
- return mem_del_entry(dir, FALSE);
+ return memfs_del_entry(dir, FALSE);
/* Remove from root */
- ret = mem_del_entry(memfs->root, FALSE);
+ ret = memfs_del_entry(memfs->root, FALSE);
memfs->root = silc_calloc(1, sizeof(*memfs->root));
if (!memfs->root)
memfs->root->perm = memfs->root_perm;
memfs->root->directory = TRUE;
memfs->root->name = strdup(DIR_SEPARATOR);
+ if (!memfs->root->name) {
+ silc_free(memfs->root);
+ memfs->root = NULL;
+ return FALSE;
+ }
return ret;
}
file and they work in POSIX style. Returns TRUE if the file was
added to the directory. */
-bool silc_sftp_fs_memory_add_file(SilcSFTPFilesystem fs, void *dir,
- SilcSFTPFSMemoryPerm perm,
- const char *filename,
- const char *realpath)
+SilcBool silc_sftp_fs_memory_add_file(SilcSFTPFilesystem fs, void *dir,
+ SilcSFTPFSMemoryPerm perm,
+ const char *filename,
+ const char *realpath)
{
MemFS memfs = (MemFS)fs->fs_context;
MemFSEntry entry;
return FALSE;
entry->perm = perm;
+ entry->directory = FALSE;
entry->name = strdup(filename);
entry->data = strdup(realpath);
- entry->directory = FALSE;
+ if (!entry->name || !entry->data) {
+ silc_free(entry->name);
+ silc_free(entry->data);
+ silc_free(entry);
+ return FALSE;
+ }
- return mem_add_entry(dir ? dir : memfs->root, entry, FALSE);
+ return memfs_add_entry(dir ? dir : memfs->root, entry, FALSE);
}
/* Removes a file indicated by the `filename' from the directory
indicated by the `dir'. Returns TRUE if the removing was success. */
-bool silc_sftp_fs_memory_del_file(SilcSFTPFilesystem fs, void *dir,
- const char *filename)
+SilcBool silc_sftp_fs_memory_del_file(SilcSFTPFilesystem fs, void *dir,
+ const char *filename)
{
MemFS memfs = (MemFS)fs->fs_context;
if (!filename)
return FALSE;
- return mem_del_entry_name(dir ? dir : memfs->root, filename,
+ return memfs_del_entry_name(dir ? dir : memfs->root, filename,
strlen(filename), FALSE);
}
-SilcSFTPHandle mem_get_handle(void *context, SilcSFTP sftp,
- const unsigned char *data,
- SilcUInt32 data_len)
+SilcSFTPHandle memfs_get_handle(void *context, SilcSFTP sftp,
+ const unsigned char *data,
+ SilcUInt32 data_len)
{
MemFS fs = (MemFS)context;
SilcUInt32 handle;
return NULL;
SILC_GET32_MSB(handle, data);
- return (SilcSFTPHandle)mem_find_handle(fs, handle);
+ return (SilcSFTPHandle)memfs_find_handle(fs, handle);
}
-unsigned char *mem_encode_handle(void *context, SilcSFTP sftp,
- SilcSFTPHandle handle,
- SilcUInt32 *handle_len)
+unsigned char *memfs_encode_handle(void *context, SilcSFTP sftp,
+ SilcSFTPHandle handle,
+ SilcUInt32 *handle_len)
{
unsigned char *data;
MemFSFileHandle h = (MemFSFileHandle)handle;
return data;
}
-void mem_open(void *context, SilcSFTP sftp,
- const char *filename,
- SilcSFTPFileOperation pflags,
- SilcSFTPAttributes attrs,
- SilcSFTPHandleCallback callback,
- void *callback_context)
+void memfs_open(void *context, SilcSFTP sftp,
+ const char *filename,
+ SilcSFTPFileOperation pflags,
+ SilcSFTPAttributes attrs,
+ SilcSFTPHandleCallback callback,
+ void *callback_context)
{
MemFS fs = (MemFS)context;
MemFSEntry entry;
}
/* Find such file */
- entry = mem_find_entry_path(fs->root, filename);
+ entry = memfs_find_entry_path(fs->root, filename);
if (!entry) {
(*callback)(sftp, SILC_SFTP_STATUS_NO_SUCH_FILE, NULL, callback_context);
return;
(attrs->flags & SILC_SFTP_ATTR_PERMISSIONS ?
attrs->permissions : 0600));
if (fd == -1) {
- (*callback)(sftp, silc_sftp_map_errno(errno), NULL, callback_context);
+ (*callback)(sftp, silc_sftp_map_errno(silc_errno), NULL, callback_context);
return;
}
/* File opened, return handle */
- handle = mem_create_handle(fs, fd, entry);
+ handle = memfs_create_handle(fs, fd, entry);
if (handle)
(*callback)(sftp, SILC_SFTP_STATUS_OK, (SilcSFTPHandle)handle,
callback_context);
callback_context);
}
-void mem_close(void *context, SilcSFTP sftp,
- SilcSFTPHandle handle,
- SilcSFTPStatusCallback callback,
- void *callback_context)
+void memfs_close(void *context, SilcSFTP sftp,
+ SilcSFTPHandle handle,
+ SilcSFTPStatusCallback callback,
+ void *callback_context)
{
MemFS fs = (MemFS)context;
MemFSFileHandle h = (MemFSFileHandle)handle;
if (h->fd != -1) {
ret = silc_file_close(h->fd);
if (ret == -1) {
- (*callback)(sftp, silc_sftp_map_errno(errno), NULL, NULL,
+ (*callback)(sftp, silc_sftp_map_errno(silc_errno), NULL, NULL,
callback_context);
return;
}
}
- mem_del_handle(fs, h);
+ memfs_del_handle(fs, h);
(*callback)(sftp, SILC_SFTP_STATUS_OK, NULL, NULL, callback_context);
}
-void mem_read(void *context, SilcSFTP sftp,
- SilcSFTPHandle handle,
- SilcUInt64 offset,
- SilcUInt32 len,
- SilcSFTPDataCallback callback,
- void *callback_context)
+void memfs_read(void *context, SilcSFTP sftp,
+ SilcSFTPHandle handle,
+ SilcUInt64 offset,
+ SilcUInt32 len,
+ SilcSFTPDataCallback callback,
+ void *callback_context)
{
MemFSFileHandle h = (MemFSFileHandle)handle;
- unsigned char *data;
+ unsigned char data[63488];
int ret;
- if (len > 32768)
- len = 32768;
+ if (len > 63488)
+ len = 63488;
- data = silc_malloc(len);
- if (!data) {
- (*callback)(sftp, SILC_SFTP_STATUS_EOF, NULL, 0, callback_context);
+ ret = lseek(h->fd, (off_t)offset, SEEK_SET);
+ if (ret < 0) {
+ if (!ret)
+ (*callback)(sftp, SILC_SFTP_STATUS_EOF, NULL, 0, callback_context);
+ else
+ (*callback)(sftp, silc_sftp_map_errno(silc_errno),
+ NULL, 0, callback_context);
return;
}
- lseek(h->fd, (off_t)offset, SEEK_SET);
/* Attempt to read */
ret = silc_file_read(h->fd, data, len);
if (!ret)
(*callback)(sftp, SILC_SFTP_STATUS_EOF, NULL, 0, callback_context);
else
- (*callback)(sftp, silc_sftp_map_errno(errno), NULL, 0, callback_context);
- silc_free(data);
+ (*callback)(sftp, silc_sftp_map_errno(silc_errno),
+ NULL, 0, callback_context);
return;
}
/* Return data */
(*callback)(sftp, SILC_SFTP_STATUS_OK, (const unsigned char *)data,
ret, callback_context);
-
- silc_free(data);
}
-void mem_write(void *context, SilcSFTP sftp,
- SilcSFTPHandle handle,
- SilcUInt64 offset,
- const unsigned char *data,
- SilcUInt32 data_len,
- SilcSFTPStatusCallback callback,
- void *callback_context)
+void memfs_write(void *context, SilcSFTP sftp,
+ SilcSFTPHandle handle,
+ SilcUInt64 offset,
+ const unsigned char *data,
+ SilcUInt32 data_len,
+ SilcSFTPStatusCallback callback,
+ void *callback_context)
{
MemFSFileHandle h = (MemFSFileHandle)handle;
int ret;
/* Attempt to write */
ret = silc_file_write(h->fd, data, data_len);
if (ret <= 0) {
- (*callback)(sftp, silc_sftp_map_errno(errno), NULL, NULL,
+ (*callback)(sftp, silc_sftp_map_errno(silc_errno), NULL, NULL,
callback_context);
return;
}
(*callback)(sftp, SILC_SFTP_STATUS_OK, NULL, NULL, callback_context);
}
-void mem_remove(void *context, SilcSFTP sftp,
- const char *filename,
- SilcSFTPStatusCallback callback,
- void *callback_context)
+void memfs_remove(void *context, SilcSFTP sftp,
+ const char *filename,
+ SilcSFTPStatusCallback callback,
+ void *callback_context)
{
/* Remove is not supported */
(*callback)(sftp, SILC_SFTP_STATUS_OP_UNSUPPORTED, NULL, NULL,
callback_context);
}
-void mem_rename(void *context, SilcSFTP sftp,
- const char *oldname,
- const char *newname,
- SilcSFTPStatusCallback callback,
- void *callback_context)
+void memfs_rename(void *context, SilcSFTP sftp,
+ const char *oldname,
+ const char *newname,
+ SilcSFTPStatusCallback callback,
+ void *callback_context)
{
/* Rename is not supported */
(*callback)(sftp, SILC_SFTP_STATUS_OP_UNSUPPORTED, NULL, NULL,
callback_context);
}
-void mem_mkdir(void *context, SilcSFTP sftp,
- const char *path,
- SilcSFTPAttributes attrs,
- SilcSFTPStatusCallback callback,
- void *callback_context)
+void memfs_mkdir(void *context, SilcSFTP sftp,
+ const char *path,
+ SilcSFTPAttributes attrs,
+ SilcSFTPStatusCallback callback,
+ void *callback_context)
{
/* Mkdir is not supported */
(*callback)(sftp, SILC_SFTP_STATUS_OP_UNSUPPORTED, NULL, NULL,
callback_context);
}
-void mem_rmdir(void *context, SilcSFTP sftp,
- const char *path,
- SilcSFTPStatusCallback callback,
- void *callback_context)
+void memfs_rmdir(void *context, SilcSFTP sftp,
+ const char *path,
+ SilcSFTPStatusCallback callback,
+ void *callback_context)
{
/* Rmdir is not supported */
(*callback)(sftp, SILC_SFTP_STATUS_OP_UNSUPPORTED, NULL, NULL,
callback_context);
}
-void mem_opendir(void *context, SilcSFTP sftp,
- const char *path,
- SilcSFTPHandleCallback callback,
- void *callback_context)
+void memfs_opendir(void *context, SilcSFTP sftp,
+ const char *path,
+ SilcSFTPHandleCallback callback,
+ void *callback_context)
{
MemFS fs = (MemFS)context;
MemFSEntry entry;
path = (const char *)DIR_SEPARATOR;
/* Find such directory */
- entry = mem_find_entry_path(fs->root, path);
+ entry = memfs_find_entry_path(fs->root, path);
if (!entry) {
(*callback)(sftp, SILC_SFTP_STATUS_NO_SUCH_FILE, NULL, callback_context);
return;
}
/* Directory opened, return handle */
- handle = mem_create_handle(fs, 0, entry);
+ handle = memfs_create_handle(fs, 0, entry);
if (handle)
(*callback)(sftp, SILC_SFTP_STATUS_OK, (SilcSFTPHandle)handle,
callback_context);
callback_context);
}
-void mem_readdir(void *context, SilcSFTP sftp,
- SilcSFTPHandle handle,
- SilcSFTPNameCallback callback,
- void *callback_context)
+void memfs_readdir(void *context, SilcSFTP sftp,
+ SilcSFTPHandle handle,
+ SilcSFTPNameCallback callback,
+ void *callback_context)
{
MemFSFileHandle h = (MemFSFileHandle)handle;
MemFSEntry entry;
char long_name[256];
SilcUInt64 filesize = 0;
char *date;
- struct stat stats;
+ SilcFileStatStruct stats;
if (!h->entry->directory) {
(*callback)(sftp, SILC_SFTP_STATUS_FAILURE, NULL, callback_context);
filesize = sizeof(*entry);
memset(long_name, 0, sizeof(long_name));
- date = (char *)silc_get_time(entry->created);
+ date = (char *)silc_time_string(entry->created);
if (strrchr(date, ':'))
*strrchr(date, ':') = '\0';
if (!entry->directory) {
filesize = silc_file_size(entry->data + 7);
- memset(&stats, 0, sizeof(stats));
- stat(entry->data + 7, &stats);
+ silc_file_stat(entry->data + 7, TRUE, &stats);
}
/* Long name format is:
drwx------ 1 324210 Apr 8 08:40 mail/
1234567890 123 12345678 123456789012 */
- snprintf(long_name, sizeof(long_name) - 1,
+ silc_snprintf(long_name, sizeof(long_name) - 1,
"%c%c%c%c------ %3d %8llu %12s %s%s",
(entry->directory ? 'd' : '-'),
((entry->perm & SILC_SFTP_FS_PERM_READ) ? 'r' : '-'),
attrs->gid = 0;
if (!entry->directory) {
attrs->flags |= SILC_SFTP_ATTR_ACMODTIME;
- attrs->atime = stats.st_atime;
- attrs->mtime = stats.st_mtime;
+ attrs->atime = silc_time_epoch(&stats.last_access);
+ attrs->mtime = silc_time_epoch(&stats.last_mod);
}
/* Add the name */
silc_sftp_name_free(name);
}
-void mem_stat(void *context, SilcSFTP sftp,
- const char *path,
- SilcSFTPAttrCallback callback,
- void *callback_context)
+void memfs_stat(void *context, SilcSFTP sftp,
+ const char *path,
+ SilcSFTPAttrCallback callback,
+ void *callback_context)
{
MemFS fs = (MemFS)context;
MemFSEntry entry;
SilcSFTPAttributes attrs;
- int ret;
- struct stat stats;
+ SilcFileStatStruct stats;
if (!path || !strlen(path))
path = (const char *)DIR_SEPARATOR;
/* Find such directory */
- entry = mem_find_entry_path(fs->root, path);
+ entry = memfs_find_entry_path(fs->root, path);
if (!entry) {
(*callback)(sftp, SILC_SFTP_STATUS_NO_SUCH_FILE, NULL, callback_context);
return;
}
/* Get real stat */
- ret = stat(entry->data + 7, &stats);
- if (ret == -1) {
- (*callback)(sftp, silc_sftp_map_errno(errno), NULL, callback_context);
+ if (!silc_file_stat(entry->data + 7, TRUE, &stats)) {
+ (*callback)(sftp, silc_sftp_map_errno(silc_errno), NULL, callback_context);
return;
}
attrs->flags = (SILC_SFTP_ATTR_SIZE |
SILC_SFTP_ATTR_UIDGID |
SILC_SFTP_ATTR_ACMODTIME);
- attrs->size = stats.st_size;
+ attrs->size = stats.size;
attrs->uid = 0; /* We use always 0 UID and GID */
attrs->gid = 0;
- attrs->atime = stats.st_atime;
- attrs->mtime = stats.st_mtime;
+ attrs->atime = silc_time_epoch(&stats.last_access);
+ attrs->mtime = silc_time_epoch(&stats.last_mod);
/* Return attributes */
(*callback)(sftp, SILC_SFTP_STATUS_OK, (const SilcSFTPAttributes)attrs,
silc_sftp_attr_free(attrs);
}
-void mem_lstat(void *context, SilcSFTP sftp,
- const char *path,
- SilcSFTPAttrCallback callback,
- void *callback_context)
+void memfs_lstat(void *context, SilcSFTP sftp,
+ const char *path,
+ SilcSFTPAttrCallback callback,
+ void *callback_context)
{
MemFS fs = (MemFS)context;
MemFSEntry entry;
SilcSFTPAttributes attrs;
- int ret;
- struct stat stats;
+ SilcFileStatStruct stats;
if (!path || !strlen(path))
path = (const char *)DIR_SEPARATOR;
/* Find such directory */
- entry = mem_find_entry_path(fs->root, path);
+ entry = memfs_find_entry_path(fs->root, path);
if (!entry) {
(*callback)(sftp, SILC_SFTP_STATUS_NO_SUCH_FILE, NULL, callback_context);
return;
}
/* Get real stat */
-#ifndef SILC_WIN32
- ret = lstat(entry->data + 7, &stats);
-#else
- ret = stat(entry->data + 7, &stats);
-#endif
- if (ret == -1) {
- (*callback)(sftp, silc_sftp_map_errno(errno), NULL, callback_context);
+ if (!silc_file_stat(entry->data + 7, FALSE, &stats)) {
+ (*callback)(sftp, silc_sftp_map_errno(silc_errno), NULL, callback_context);
return;
}
attrs->flags = (SILC_SFTP_ATTR_SIZE |
SILC_SFTP_ATTR_UIDGID |
SILC_SFTP_ATTR_ACMODTIME);
- attrs->size = stats.st_size;
+ attrs->size = stats.size;
attrs->uid = 0; /* We use always 0 UID and GID */
attrs->gid = 0;
- attrs->atime = stats.st_atime;
- attrs->mtime = stats.st_mtime;
+ attrs->atime = silc_time_epoch(&stats.last_access);
+ attrs->mtime = silc_time_epoch(&stats.last_mod);
/* Return attributes */
(*callback)(sftp, SILC_SFTP_STATUS_OK, (const SilcSFTPAttributes)attrs,
silc_sftp_attr_free(attrs);
}
-void mem_fstat(void *context, SilcSFTP sftp,
- SilcSFTPHandle handle,
- SilcSFTPAttrCallback callback,
- void *callback_context)
+void memfs_fstat(void *context, SilcSFTP sftp,
+ SilcSFTPHandle handle,
+ SilcSFTPAttrCallback callback,
+ void *callback_context)
{
MemFSFileHandle h = (MemFSFileHandle)handle;
SilcSFTPAttributes attrs;
- int ret;
- struct stat stats;
+ SilcFileStatStruct stats;
if (h->entry->directory || !h->entry->data) {
(*callback)(sftp, SILC_SFTP_STATUS_FAILURE, NULL, callback_context);
}
/* Get real stat */
- ret = fstat(h->fd, &stats);
- if (ret == -1) {
- (*callback)(sftp, silc_sftp_map_errno(errno), NULL, callback_context);
+ if (!silc_file_fstat(h->fd, &stats)) {
+ (*callback)(sftp, silc_sftp_map_errno(silc_errno), NULL, callback_context);
return;
}
attrs->flags = (SILC_SFTP_ATTR_SIZE |
SILC_SFTP_ATTR_UIDGID |
SILC_SFTP_ATTR_ACMODTIME);
- attrs->size = stats.st_size;
+ attrs->size = stats.size;
attrs->uid = 0; /* We use always 0 UID and GID */
attrs->gid = 0;
- attrs->atime = stats.st_atime;
- attrs->mtime = stats.st_mtime;
+ attrs->atime = silc_time_epoch(&stats.last_access);
+ attrs->mtime = silc_time_epoch(&stats.last_mod);
/* Return attributes */
(*callback)(sftp, SILC_SFTP_STATUS_OK, (const SilcSFTPAttributes)attrs,
silc_sftp_attr_free(attrs);
}
-void mem_setstat(void *context, SilcSFTP sftp,
- const char *path,
- SilcSFTPAttributes attrs,
- SilcSFTPStatusCallback callback,
- void *callback_context)
+void memfs_setstat(void *context, SilcSFTP sftp,
+ const char *path,
+ SilcSFTPAttributes attrs,
+ SilcSFTPStatusCallback callback,
+ void *callback_context)
{
/* Setstat is not supported */
(*callback)(sftp, SILC_SFTP_STATUS_OP_UNSUPPORTED, NULL, NULL,
callback_context);
}
-void mem_fsetstat(void *context, SilcSFTP sftp,
- SilcSFTPHandle handle,
- SilcSFTPAttributes attrs,
- SilcSFTPStatusCallback callback,
- void *callback_context)
+void memfs_fsetstat(void *context, SilcSFTP sftp,
+ SilcSFTPHandle handle,
+ SilcSFTPAttributes attrs,
+ SilcSFTPStatusCallback callback,
+ void *callback_context)
{
/* Fsetstat is not supported */
(*callback)(sftp, SILC_SFTP_STATUS_OP_UNSUPPORTED, NULL, NULL,
callback_context);
}
-void mem_readlink(void *context, SilcSFTP sftp,
- const char *path,
- SilcSFTPNameCallback callback,
- void *callback_context)
+void memfs_readlink(void *context, SilcSFTP sftp,
+ const char *path,
+ SilcSFTPNameCallback callback,
+ void *callback_context)
{
/* Readlink is not supported */
(*callback)(sftp, SILC_SFTP_STATUS_OP_UNSUPPORTED, NULL,
callback_context);
}
-void mem_symlink(void *context, SilcSFTP sftp,
- const char *linkpath,
- const char *targetpath,
- SilcSFTPStatusCallback callback,
- void *callback_context)
+void memfs_symlink(void *context, SilcSFTP sftp,
+ const char *linkpath,
+ const char *targetpath,
+ SilcSFTPStatusCallback callback,
+ void *callback_context)
{
/* Symlink is not supported */
(*callback)(sftp, SILC_SFTP_STATUS_OP_UNSUPPORTED, NULL, NULL,
callback_context);
}
-void mem_realpath(void *context, SilcSFTP sftp,
- const char *path,
- SilcSFTPNameCallback callback,
- void *callback_context)
+void memfs_realpath(void *context, SilcSFTP sftp,
+ const char *path,
+ SilcSFTPNameCallback callback,
+ void *callback_context)
{
MemFS fs = (MemFS)context;
char *realpath;
if (!path || !strlen(path))
path = (const char *)DIR_SEPARATOR;
- realpath = mem_expand_path(fs->root, path);
+ realpath = memfs_expand_path(fs->root, path);
if (!realpath)
goto fail;
(*callback)(sftp, SILC_SFTP_STATUS_FAILURE, NULL, callback_context);
}
-void mem_extended(void *context, SilcSFTP sftp,
- const char *request,
- const unsigned char *data,
- SilcUInt32 data_len,
- SilcSFTPExtendedCallback callback,
- void *callback_context)
+void memfs_extended(void *context, SilcSFTP sftp,
+ const char *request,
+ const unsigned char *data,
+ SilcUInt32 data_len,
+ SilcSFTPExtendedCallback callback,
+ void *callback_context)
{
/* Extended is not supported */
(*callback)(sftp, SILC_SFTP_STATUS_OP_UNSUPPORTED, NULL, 0,
}
const struct SilcSFTPFilesystemOpsStruct silc_sftp_fs_memory = {
- mem_get_handle,
- mem_encode_handle,
- mem_open,
- mem_close,
- mem_read,
- mem_write,
- mem_remove,
- mem_rename,
- mem_mkdir,
- mem_rmdir,
- mem_opendir,
- mem_readdir,
- mem_stat,
- mem_lstat,
- mem_fstat,
- mem_setstat,
- mem_fsetstat,
- mem_readlink,
- mem_symlink,
- mem_realpath,
- mem_extended
+ memfs_get_handle,
+ memfs_encode_handle,
+ memfs_open,
+ memfs_close,
+ memfs_read,
+ memfs_write,
+ memfs_remove,
+ memfs_rename,
+ memfs_mkdir,
+ memfs_rmdir,
+ memfs_opendir,
+ memfs_readdir,
+ memfs_stat,
+ memfs_lstat,
+ memfs_fstat,
+ memfs_setstat,
+ memfs_fsetstat,
+ memfs_readlink,
+ memfs_symlink,
+ memfs_realpath,
+ memfs_extended
};
projects / silc.git / blobdiff