static void test_copyEqualBuffer(void **state)
{
char element0[] = "element0";
unsigned int element0size = strlen(element0);
char element1[] = "element1";
unsigned int element1size = strlen(element1);
Buffer *buffer0 = NULL;
Buffer *buffer1 = NULL;
Buffer *buffer2 = NULL;
// Empty buffers, all empty buffers are the same
assert_int_equal(0, BufferNew(&buffer0));
assert_int_equal(0, BufferNew(&buffer1));
assert_true(BufferEqual(buffer0, buffer0));
assert_true(BufferEqual(buffer0, buffer1));
assert_int_equal(0, BufferCopy(buffer0, &buffer2));
assert_true(BufferEqual(buffer0, buffer2));
// Add some flavour
assert_int_equal(0, BufferDestroy(&buffer2));
assert_int_equal(element0size, BufferSet(buffer0, element0, element0size));
assert_int_equal(element1size, BufferSet(buffer1, element1, element1size));
assert_true(BufferEqual(buffer0, buffer0));
assert_false(BufferEqual(buffer0, buffer1));
assert_int_equal(0, BufferCopy(buffer0, &buffer2));
assert_true(BufferEqual(buffer0, buffer2));
// Destroy the buffers
assert_int_equal(0, BufferDestroy(&buffer0));
assert_int_equal(0, BufferDestroy(&buffer1));
assert_int_equal(0, BufferDestroy(&buffer2));
}
Buffer *IPAddressGetAddress(IPAddress *address)
{
if (!address)
{
return NULL;
}
Buffer *buffer = NULL;
int result = 0;
if (address->type == IP_ADDRESS_TYPE_IPV4)
{
struct IPV4Address *ipv4 = (struct IPV4Address *)address->address;
buffer = BufferNew();
#if BIG_ENDIAN
result = BufferPrintf(buffer, "%u.%u.%u.%u", ipv4->octets[0], ipv4->octets[1], ipv4->octets[2], ipv4->octets[3]);
#elif LITTLE_ENDIAN
result = BufferPrintf(buffer, "%u.%u.%u.%u", ipv4->octets[3], ipv4->octets[2], ipv4->octets[1], ipv4->octets[0]);
#else
#warning "Unrecognized endianness, assuming big endian"
result = BufferPrintf(buffer, "%u.%u.%u.%u", ipv4->octets[0], ipv4->octets[1], ipv4->octets[2], ipv4->octets[3]);
#endif
}
else if (address->type == IP_ADDRESS_TYPE_IPV6)
{
struct IPV6Address *ipv6 = (struct IPV6Address *)address->address;
buffer = BufferNew();
#if BIG_ENDIAN
result = BufferPrintf(buffer, "%x:%x:%x:%x:%x:%x:%x:%x", ipv6->sixteen[0], ipv6->sixteen[1], ipv6->sixteen[2],
ipv6->sixteen[3], ipv6->sixteen[4], ipv6->sixteen[5], ipv6->sixteen[6], ipv6->sixteen[7]);
#elif LITTLE_ENDIAN
result = BufferPrintf(buffer, "%x:%x:%x:%x:%x:%x:%x:%x", ipv6->sixteen[7], ipv6->sixteen[6], ipv6->sixteen[5],
ipv6->sixteen[4], ipv6->sixteen[3], ipv6->sixteen[2], ipv6->sixteen[1], ipv6->sixteen[0]);
#else
#warning "Unrecognized endianness, assuming big endian"
result = BufferPrintf(buffer, "%x:%x:%x:%x:%x:%x:%x:%x", ipv6->sixteen[0], ipv6->sixteen[1], ipv6->sixteen[2],
ipv6->sixteen[3], ipv6->sixteen[4], ipv6->sixteen[5], ipv6->sixteen[6], ipv6->sixteen[7]);
#endif
}
else
{
buffer = NULL;
}
if (result < 0)
{
BufferDestroy(buffer);
return NULL;
}
return buffer;
}
static void test_createBuffer(void **state)
{
Buffer *buffer = NULL;
assert_int_equal(0, BufferNew(&buffer));
assert_true(buffer != NULL);
assert_true(buffer->buffer != NULL);
assert_int_equal(buffer->mode, BUFFER_BEHAVIOR_CSTRING);
assert_int_equal(buffer->capacity, DEFAULT_BUFFER_SIZE);
assert_int_equal(buffer->used, 0);
assert_int_equal(buffer->beginning, 0);
assert_int_equal(buffer->end, 0);
assert_true(buffer->ref_count != NULL);
assert_int_equal(buffer->ref_count->user_count, 1);
assert_int_equal(-1, BufferNew(NULL));
}
char *VarRefToString(const VarRef *ref, bool qualified)
{
assert(ref->lval);
Buffer *buf = BufferNew();
if (qualified && VarRefIsQualified(ref))
{
const char *ns = ref->ns ? ref->ns : "default";
BufferAppend(buf, ns, strlen(ns));
BufferAppend(buf, ":", sizeof(char));
BufferAppend(buf, ref->scope, strlen(ref->scope));
BufferAppend(buf, ".", sizeof(char));
}
BufferAppend(buf, ref->lval, strlen(ref->lval));
for (size_t i = 0; i < ref->num_indices; i++)
{
BufferAppend(buf, "[", sizeof(char));
BufferAppend(buf, ref->indices[i], strlen(ref->indices[i]));
BufferAppend(buf, "]", sizeof(char));
}
char *var_string = xstrdup(BufferData(buf));
BufferDestroy(&buf);
return var_string;
}
static void test_zeroBuffer(void)
{
char *element0 = xstrdup("element0");
unsigned int element0size = strlen(element0);
const char *element0pointer = NULL;
Buffer *buffer = BufferNew();
assert_int_equal(element0size, BufferSet(buffer, element0, element0size));
element0pointer = buffer->buffer;
assert_int_equal(element0size, buffer->used);
assert_int_equal(element0size, BufferSize(buffer));
BufferZero(buffer);
assert_int_equal(DEFAULT_BUFFER_SIZE, buffer->capacity);
assert_int_equal(0, buffer->used);
assert_int_equal(0, BufferSize(buffer));
const char *data = BufferData(buffer);
assert_string_equal(data, "");
assert_true(element0pointer == buffer->buffer);
BufferZero(NULL);
assert_int_equal(0, BufferDestroy(&buffer));
/*
* Release the resources
*/
BufferDestroy(&buffer);
free (element0);
}
Buffer *StringSetToBuffer(StringSet *set, const char delimiter)
{
Buffer *buf = BufferNew();
StringSetIterator it = StringSetIteratorInit(set);
const char *element = NULL;
int pos = 0;
int size = StringSetSize(set);
char minibuf[2];
minibuf[0] = delimiter;
minibuf[1] = '\0';
while ((element = StringSetIteratorNext(&it)))
{
BufferAppend(buf, element, strlen(element));
if (pos < size-1)
{
BufferAppend(buf, minibuf, sizeof(char));
}
pos++;
}
return buf;
}
static void test_destroyBuffer(void)
{
Buffer *buffer = BufferNew();
assert_int_equal(0, BufferDestroy(&buffer));
assert_true(buffer == NULL);
assert_int_equal(0, BufferDestroy(NULL));
}
void DoExtDiskSpace(tBuffer *bIn, tBuffer *bOut, u_int32_t id)
{
struct STATFS stfs;
tFSPath *realPath;
char *path;
path = convertFromUtf8(BufferGetString(bIn), 1);
realPath = FSCheckPath(path);
DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH]Path: %s", path));
if (realPath != NULL && !HAS_BIT(gl_var->flagsDisable, SFTP_DISABLE_STATSFS))
{
DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH]Realpath: %s", realPath->realPath));
if (STATFS(realPath->realPath, &stfs) == 0)
{
tBuffer *b;
b = BufferNew();
BufferPutInt8(b, SSH2_FXP_EXTENDED_REPLY);
BufferPutInt32(b, id);
BufferPutInt64(b, (u_int64_t) stfs.f_blocks * (u_int64_t) stfs.f_bsize);
BufferPutInt64(b, (u_int64_t) stfs.f_bfree * (u_int64_t) stfs.f_bsize);
BufferPutInt64(b, 0);
BufferPutInt64(b, (u_int64_t) stfs.f_bavail * (u_int64_t) stfs.f_bsize);
BufferPutInt32(b, stfs.f_bsize);
BufferPutPacket(bOut, b);
}
else
SendStatus(bOut, id, errnoToPortable(errno));
}
else
SendStatus(bOut, id, SSH2_FX_PERMISSION_DENIED);
FSDestroyPath(realPath);
free(path);
}
static PyObject *
WindowGetattro(PyObject *self, PyObject *nameobj)
{
WindowObject *this = (WindowObject *)(self);
char *name = "";
if (PyUnicode_Check(nameobj))
name = _PyUnicode_AsString(nameobj);
if (CheckWindow(this))
return NULL;
if (strcmp(name, "buffer") == 0)
return (PyObject *)BufferNew(this->win->w_buffer);
else if (strcmp(name, "cursor") == 0)
{
pos_T *pos = &this->win->w_cursor;
return Py_BuildValue("(ll)", (long)(pos->lnum), (long)(pos->col));
}
else if (strcmp(name, "height") == 0)
return Py_BuildValue("l", (long)(this->win->w_height));
#ifdef FEAT_VERTSPLIT
else if (strcmp(name, "width") == 0)
return Py_BuildValue("l", (long)(W_WIDTH(this->win)));
#endif
else if (strcmp(name,"__members__") == 0)
return Py_BuildValue("[sss]", "buffer", "cursor", "height");
else
return PyObject_GenericGetAttr(self, nameobj);
}
Rval ExpandBundleReference(EvalContext *ctx,
const char *ns, const char *scope,
Rval rval)
{
// Allocates new memory for the copy
switch (rval.type)
{
case RVAL_TYPE_SCALAR:
{
Buffer *buffer = BufferNew();
ExpandScalar(ctx, ns, scope, RvalScalarValue(rval), buffer);
return (Rval) { BufferClose(buffer), RVAL_TYPE_SCALAR };
}
case RVAL_TYPE_FNCALL:
return (Rval) {ExpandFnCall(ctx, ns, scope, RvalFnCallValue(rval)), RVAL_TYPE_FNCALL};
case RVAL_TYPE_CONTAINER:
case RVAL_TYPE_LIST:
case RVAL_TYPE_NOPROMISEE:
return RvalNew(NULL, RVAL_TYPE_NOPROMISEE);
}
assert(false);
return RvalNew(NULL, RVAL_TYPE_NOPROMISEE);
}
static PyObject *
WindowGetattr(PyObject *self, char *name)
{
WindowObject *this = (WindowObject *)(self);
if (CheckWindow(this))
return NULL;
if (strcmp(name, "buffer") == 0)
return (PyObject *)BufferNew(this->win->w_buffer);
else if (strcmp(name, "cursor") == 0)
{
pos_T *pos = &this->win->w_cursor;
return Py_BuildValue("(ll)", (long)(pos->lnum), (long)(pos->col));
}
else if (strcmp(name, "height") == 0)
return Py_BuildValue("l", (long)(this->win->w_height));
#ifdef FEAT_VERTSPLIT
else if (strcmp(name, "width") == 0)
return Py_BuildValue("l", (long)(W_WIDTH(this->win)));
#endif
else if (strcmp(name,"__members__") == 0)
return Py_BuildValue("[sss]", "buffer", "cursor", "height");
else
return Py_FindMethod(WindowMethods, self, name);
}
static bool Epimenides(EvalContext *ctx, const char *ns, const char *scope, const char *var, Rval rval, int level)
{
switch (rval.type)
{
case RVAL_TYPE_SCALAR:
if (StringContainsVar(RvalScalarValue(rval), var))
{
Log(LOG_LEVEL_ERR, "Scalar variable '%s' contains itself (non-convergent) '%s'", var, RvalScalarValue(rval));
return true;
}
if (IsCf3VarString(RvalScalarValue(rval)))
{
Buffer *exp = BufferNew();
ExpandScalar(ctx, ns, scope, RvalScalarValue(rval), exp);
if (strcmp(BufferData(exp), RvalScalarValue(rval)) == 0)
{
BufferDestroy(exp);
return false;
}
if (level > 3)
{
BufferDestroy(exp);
return false;
}
if (Epimenides(ctx, ns, scope, var, (Rval) { BufferGet(exp), RVAL_TYPE_SCALAR}, level + 1))
{
BufferDestroy(exp);
return true;
}
BufferDestroy(exp);
}
break;
case RVAL_TYPE_LIST:
for (const Rlist *rp = RvalRlistValue(rval); rp != NULL; rp = rp->next)
{
if (Epimenides(ctx, ns, scope, var, rp->val, level))
{
return true;
}
}
break;
case RVAL_TYPE_CONTAINER:
case RVAL_TYPE_FNCALL:
case RVAL_TYPE_NOPROMISEE:
return false;
}
return false;
}
static void test_expand_scalar_undefined(void **state)
{
EvalContext *ctx = *state;
Buffer *res = BufferNew();
ExpandScalar(ctx, "default", "bundle", "a$(undefined)b", res);
assert_string_equal("a$(undefined)b", BufferData(res));
BufferDestroy(res);
}
void CreateHardClassesFromFeatures(EvalContext *ctx, char *tags)
{
Buffer *buffer = BufferNew();
for(int i=0 ; features[i]!=NULL ; i++) {
BufferPrintf(buffer, "feature_%s", features[i]);
CreateHardClassesFromCanonification(ctx, BufferData(buffer), tags);
}
BufferDestroy(buffer);
}
static PromiseResult ExpandPromiseAndDo(EvalContext *ctx, const Promise *pp,
Rlist *lists, Rlist *containers,
PromiseActuator *ActOnPromise, void *param)
{
const char *handle = PromiseGetHandle(pp);
EvalContextStackPushPromiseFrame(ctx, pp, true);
PromiseIterator *iter_ctx = NULL;
size_t i = 0;
PromiseResult result = PROMISE_RESULT_NOOP;
Buffer *expbuf = BufferNew();
for (iter_ctx = PromiseIteratorNew(ctx, pp, lists, containers); PromiseIteratorHasMore(iter_ctx); i++, PromiseIteratorNext(iter_ctx))
{
if (handle)
{
// This ordering is necessary to get automated canonification
BufferClear(expbuf);
ExpandScalar(ctx, NULL, "this", handle, expbuf);
CanonifyNameInPlace(BufferGet(expbuf));
EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "handle", BufferData(expbuf), CF_DATA_TYPE_STRING, "source=promise");
}
else
{
EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "handle", PromiseID(pp), CF_DATA_TYPE_STRING, "source=promise");
}
const Promise *pexp = EvalContextStackPushPromiseIterationFrame(ctx, i, iter_ctx);
if (!pexp)
{
// excluded
result = PromiseResultUpdate(result, PROMISE_RESULT_SKIPPED);
continue;
}
PromiseResult iteration_result = ActOnPromise(ctx, pexp, param);
NotifyDependantPromises(ctx, pexp, iteration_result);
result = PromiseResultUpdate(result, iteration_result);
if (strcmp(pp->parent_promise_type->name, "vars") == 0 || strcmp(pp->parent_promise_type->name, "meta") == 0)
{
VerifyVarPromise(ctx, pexp, true);
}
EvalContextStackPopFrame(ctx);
}
BufferDestroy(expbuf);
PromiseIteratorDestroy(iter_ctx);
EvalContextStackPopFrame(ctx);
return result;
}
static void test_copyCompareBuffer(void)
{
char *element0 = xstrdup("element0");
unsigned int element0size = strlen(element0);
char *element1 = xstrdup("element1");
unsigned int element1size = strlen(element1);
Buffer *buffer0 = NULL;
Buffer *buffer1 = NULL;
Buffer *buffer2 = NULL;
assert_int_equal(0, BufferCompare(buffer0, buffer1));
buffer0 = BufferNew();
assert_int_equal(-1, BufferCompare(NULL, buffer0));
assert_int_equal(1, BufferCompare(buffer0, NULL));
buffer1 = BufferNew();
assert_int_equal(0, BufferCompare(buffer0, buffer0));
assert_int_equal(0, BufferCompare(buffer0, buffer1));
assert_int_equal(0, BufferCopy(buffer0, &buffer2));
assert_int_equal(0, BufferCompare(buffer0, buffer2));
// Add some flavour
assert_int_equal(0, BufferDestroy(&buffer2));
assert_int_equal(element0size, BufferSet(buffer0, element0, element0size));
assert_int_equal(element1size, BufferSet(buffer1, element1, element1size));
assert_int_equal(0, BufferCompare(buffer0, buffer0));
assert_int_equal(-1, BufferCompare(buffer0, buffer1));
assert_int_equal(1, BufferCompare(buffer1, buffer0));
assert_int_equal(0, BufferCopy(buffer0, &buffer2));
assert_int_equal(0, BufferCompare(buffer0, buffer2));
// Destroy the buffers
assert_int_equal(0, BufferDestroy(&buffer0));
assert_int_equal(0, BufferDestroy(&buffer1));
assert_int_equal(0, BufferDestroy(&buffer2));
free (element0);
free (element1);
}
void DoAdminStats(tStats *stats)
{
u_int32_t lastRefresh;
tBuffer *b;
lastRefresh = BufferGetInt32(bIn);
b = BufferNew();
BufferPutInt8FAST(b, SSH_ADMIN_STATS_REPLY);
StatsSend(stats, lastRefresh, b);
BufferPutPacket(bOut, b);
DEBUG((MYLOG_DEBUG, "[DoAdminStats]Last refresh :%u", lastRefresh));
BufferDelete(b);
}
void SendAttributes(tBuffer *bOut, u_int32_t id, const tAttributes *a, const char *file)
{
tBuffer *b;
b = BufferNew();
if (b != NULL)
{
BufferPutInt8FAST(b, SSH2_FXP_ATTRS);
BufferPutInt32(b, id);
EncodeAttributes(b, a, file);
BufferPutPacket(bOut, b);
BufferDelete(b);
}
}
static void test_expand_scalar_nested_inner_undefined(void **state)
{
EvalContext *ctx = *state;
{
VarRef *lval = VarRefParse("default:bundle.foo[one]");
EvalContextVariablePut(ctx, lval, "first", CF_DATA_TYPE_STRING, NULL);
VarRefDestroy(lval);
}
Buffer *res = BufferNew();
ExpandScalar(ctx, "default", "bundle", "a$(foo[$(undefined)])b", res);
assert_string_equal("a$(foo[$(undefined)])b", BufferData(res));
BufferDestroy(res);
}
static VersionCmpResult RunCmpCommand(EvalContext *ctx, const char *command, const char *v1, const char *v2, Attributes a,
const Promise *pp, PromiseResult *result)
{
Buffer *expanded_command = BufferNew();
{
VarRef *ref_v1 = VarRefParseFromScope("v1", PACKAGES_CONTEXT);
EvalContextVariablePut(ctx, ref_v1, v1, CF_DATA_TYPE_STRING, "source=promise");
VarRef *ref_v2 = VarRefParseFromScope("v2", PACKAGES_CONTEXT);
EvalContextVariablePut(ctx, ref_v2, v2, CF_DATA_TYPE_STRING, "source=promise");
ExpandScalar(ctx, NULL, PACKAGES_CONTEXT, command, expanded_command);
EvalContextVariableRemove(ctx, ref_v1);
VarRefDestroy(ref_v1);
EvalContextVariableRemove(ctx, ref_v2);
VarRefDestroy(ref_v2);
}
FILE *pfp = a.packages.package_commands_useshell ? cf_popen_sh(BufferData(expanded_command), "w") : cf_popen(BufferData(expanded_command), "w", true);
if (pfp == NULL)
{
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "Can not start package version comparison command '%s'. (cf_popen: %s)",
BufferData(expanded_command), GetErrorStr());
*result = PromiseResultUpdate(*result, PROMISE_RESULT_FAIL);
BufferDestroy(expanded_command);
return VERCMP_ERROR;
}
Log(LOG_LEVEL_VERBOSE, "Executing '%s'", BufferData(expanded_command));
int retcode = cf_pclose(pfp);
if (retcode == -1)
{
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "Error during package version comparison command execution '%s'. (cf_pclose: %s)",
BufferData(expanded_command), GetErrorStr());
*result = PromiseResultUpdate(*result, PROMISE_RESULT_FAIL);
BufferDestroy(expanded_command);
return VERCMP_ERROR;
}
BufferDestroy(expanded_command);
return retcode == 0;
}
static void test_extract_reference_(const char *scalar, bool expect_success, const char *outer, const char *inner)
{
Buffer *b = BufferNew();
size_t len = strlen(scalar);
bool success = ExtractScalarReference(b, scalar, len, false);
assert_true(success == expect_success);
assert_string_equal(outer, BufferData(b));
BufferClear(b);
success = ExtractScalarReference(b, scalar, len, true);
assert_true(success == expect_success);
assert_string_equal(inner, BufferData(b));
BufferDestroy(b);
}
static void test_generic_interface(void)
{
/*
* This test might seem short, but it is intentional.
* All the parsing tests should be implemented directly
* on the corresponding parser test. Keep this test as
* lean as possible.
*/
IPAddress *address = NULL;
Buffer *buffer = NULL;
buffer = BufferNew();
assert_true(buffer != NULL);
BufferSet(buffer, "127.0.0.1", strlen("127.0.0.1"));
address = IPAddressNew(buffer);
assert_true(address != NULL);
assert_int_equal(IP_ADDRESS_TYPE_IPV4, IPAddressType(address));
assert_string_equal("127.0.0.1", BufferData(IPAddressGetAddress(address)));
assert_int_equal(0, IPAddressGetPort(address));
assert_int_equal(0, IPAddressDestroy(&address));
BufferSet(buffer, "127.0.0.1:8080", strlen("127.0.0.1:8080"));
address = IPAddressNew(buffer);
assert_true(address != NULL);
assert_int_equal(IP_ADDRESS_TYPE_IPV4, IPAddressType(address));
assert_string_equal("127.0.0.1", BufferData(IPAddressGetAddress(address)));
assert_int_equal(8080, IPAddressGetPort(address));
assert_int_equal(0, IPAddressDestroy(&address));
BufferSet(buffer, "0:1:2:3:4:5:6:7", strlen("0:1:2:3:4:5:6:7"));
address = IPAddressNew(buffer);
assert_true(address != NULL);
assert_int_equal(IP_ADDRESS_TYPE_IPV6, IPAddressType(address));
assert_string_equal("0:1:2:3:4:5:6:7", BufferData(IPAddressGetAddress(address)));
assert_int_equal(0, IPAddressGetPort(address));
assert_int_equal(0, IPAddressDestroy(&address));
BufferSet(buffer, "[0:1:2:3:4:5:6:7]:9090", strlen("[0:1:2:3:4:5:6:7]:9090"));
address = IPAddressNew(buffer);
assert_true(address != NULL);
assert_int_equal(IP_ADDRESS_TYPE_IPV6, IPAddressType(address));
assert_string_equal("0:1:2:3:4:5:6:7", BufferData(IPAddressGetAddress(address)));
assert_int_equal(9090, IPAddressGetPort(address));
assert_int_equal(0, IPAddressDestroy(&address));
BufferDestroy(buffer);
}
void DoAdminServerGetStatus()
{
struct stat st;
tBuffer *b;
char state;
b = BufferNew();
BufferPutInt8FAST(b, SSH_ADMIN_SERVER_GET_STATUS_REPLY);
if (stat(SHUTDOWN_FILE, &st) == -1)
state = 1;
else
state = 0;
BufferPutInt8(b, state);
BufferPutPacket(bOut, b);
BufferDelete(b);
DEBUG((MYLOG_DEBUG, "[DoAdminServerGetStatus]state:'%i'", state));
}
static void DoExtDiskSpaceOpenSSH_Path(tBuffer *bOut, u_int32_t id, const char *path)
{
struct STATFS stfs;
tFSPath *realPath;
DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH_Path]Path: %s", path));
realPath = FSCheckPath(path);
if (realPath != NULL && !HAS_BIT(gl_var->flagsDisable, SFTP_DISABLE_STATSFS))
{
DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH_Path]Realpath: %s", realPath->realPath));
if (STATFS(realPath->realPath, &stfs) == 0)
{
tBuffer *b;
b = BufferNew();
BufferPutInt8(b, SSH2_FXP_EXTENDED_REPLY);
BufferPutInt32(b, id);
BufferPutInt64(b, stfs.f_bsize); /* file system block size */
BufferPutInt64(b, stfs.f_frsize); /* fundamental fs block size */
BufferPutInt64(b, stfs.f_blocks); /* number of blocks (unit f_frsize) */
BufferPutInt64(b, stfs.f_bfree); /* free blocks in file system */
BufferPutInt64(b, stfs.f_bavail); /* free blocks for non-root */
BufferPutInt64(b, stfs.f_files); /* total file inodes */
BufferPutInt64(b, stfs.f_ffree); /* free file inodes */
BufferPutInt64(b, stfs.f_favail); /* free file inodes for to non-root */
BufferPutInt64(b, stfs.f_fsid); /* file system id */
BufferPutInt64(b, stfs.f_flag); /* bit mask of f_flag values */
BufferPutInt64(b, stfs.f_namemax); /* maximum filename length */
BufferPutPacket(bOut, b);
BufferDelete(b);
}
else
{
DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH_Path]error: %s", strerror(errno)));
SendStatus(bOut, id, errnoToPortable(errno));
}
}
else
{
DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH_Path]FSCheckPath failed"));
SendStatus(bOut, id, SSH2_FX_PERMISSION_DENIED);
}
FSDestroyPath(realPath);
}
void DoAdminConfigGet()
{
struct stat st;
u_int32_t status = SSH2_FX_FAILURE;
int fd;
if (stat(CONFIG_FILE, &st) != -1 && (fd = open(CONFIG_FILE, O_RDONLY)) >= 0)
{
u_int32_t r;
tBuffer *b = BufferNew();
char *buffer;
BufferPutInt8FAST(b, SSH2_FXP_DATA);
BufferPutInt32(b, 0);
if ((buffer = malloc(st.st_size)) != NULL)
{
r = read(fd, buffer, st.st_size);
BufferPutData(b, buffer, r);
free(buffer);
status = SSH2_FX_OK;
}
xclose(fd);
if (stat("/etc/shells", &st) != -1 && (fd = open("/etc/shells", O_RDONLY)) >= 0)
{
if ((buffer = malloc(st.st_size)) != NULL)
{
r = read(fd, buffer, st.st_size);
BufferPutData(b, buffer, r);
free(buffer);
}
else
BufferPutInt32(b, 0);
xclose(fd);
}
if (status == SSH2_FX_OK)
BufferPutPacket(bOut, b);
BufferDelete(b);
}
else
status = errnoToPortable(errno);
DEBUG((MYLOG_DEBUG, "[DoAdminConfigGet]status: %i", status));
if (status != SSH2_FX_OK)
SendStatus(bOut, 0, status);
}
static void test_expand_scalar_two_scalars_nested(void **state)
{
EvalContext *ctx = *state;
{
VarRef *lval = VarRefParse("default:bundle.one");
EvalContextVariablePut(ctx, lval, "first", CF_DATA_TYPE_STRING, NULL);
VarRefDestroy(lval);
}
{
VarRef *lval = VarRefParse("default:bundle.two");
EvalContextVariablePut(ctx, lval, "one", CF_DATA_TYPE_STRING, NULL);
VarRefDestroy(lval);
}
Buffer *res = BufferNew();
ExpandScalar(ctx, "default", "bundle", "a $($(two))b", res);
assert_string_equal("a firstb", BufferData(res));
BufferDestroy(res);
}
static void test_expand_scalar_array_concat(void **state)
{
EvalContext *ctx = *state;
{
VarRef *lval = VarRefParse("default:bundle.foo[one]");
EvalContextVariablePut(ctx, lval, "first", CF_DATA_TYPE_STRING, NULL);
VarRefDestroy(lval);
}
{
VarRef *lval = VarRefParse("default:bundle.foo[two]");
EvalContextVariablePut(ctx, lval, "second", CF_DATA_TYPE_STRING, NULL);
VarRefDestroy(lval);
}
Buffer *res = BufferNew();
ExpandScalar(ctx, "default", "bundle", "a $(foo[one]) b $(foo[two])c", res);
assert_string_equal("a first b secondc", BufferData(res));
BufferDestroy(res);
}
static void test_zeroBuffer(void **state)
{
char element0[] = "element0";
unsigned int element0size = strlen(element0);
const char *element0pointer = NULL;
Buffer *buffer = NULL;
assert_int_equal(0, BufferNew(&buffer));
assert_int_equal(element0size, BufferSet(buffer, element0, element0size));
element0pointer = buffer->buffer;
assert_int_equal(element0size, buffer->used);
assert_int_equal(element0size, BufferSize(buffer));
BufferZero(buffer);
assert_int_equal(DEFAULT_BUFFER_SIZE, buffer->capacity);
assert_int_equal(0, buffer->used);
assert_int_equal(0, BufferSize(buffer));
assert_true(element0pointer == buffer->buffer);
BufferZero(NULL);
assert_int_equal(0, BufferDestroy(&buffer));
}
static void test_extract_scalar_prefix()
{
Buffer *b = BufferNew();
assert_int_equal(sizeof("hello ") - 1, ExtractScalarPrefix(b, "hello $(world) xy", sizeof("hello $(world) xy") -1));
assert_string_equal("hello ", BufferData(b));
BufferClear(b);
assert_int_equal(sizeof("hello (world) xy") -1, ExtractScalarPrefix(b, "hello (world) xy", sizeof("hello (world) xy") -1));
assert_string_equal("hello (world) xy", BufferData(b));
BufferClear(b);
assert_int_equal(sizeof("hello$)") -1, ExtractScalarPrefix(b, "hello$)$(world)xy", sizeof("hello$)$(world)xy") -1));
assert_string_equal("hello$)", BufferData(b));
BufferClear(b);
assert_int_equal(0, ExtractScalarPrefix(b, "", 0));
assert_string_equal("", BufferData(b));
BufferDestroy(b);
}
Buffer* BufferFilter(Buffer *buffer, BufferFilterFn filter, const bool invert)
{
assert(buffer);
Buffer *filtered = BufferNew();
for (unsigned int i = 0; i < buffer->used; ++i)
{
bool test = (*filter)(buffer->buffer[i]);
if (invert)
{
test = !test;
}
if (test)
{
BufferAppendChar(filtered, buffer->buffer[i]);
}
}
return filtered;
}