char * rb_proc_pid_cmdline(int pid) {
char buffer[512];
FILE *fp;
char *cmdline;
size_t size = 0;
sprintf(buffer, "/proc/%d/cmdline", pid);
fp = fopen(buffer, "rb");
if (!fp)
return NULL;
getdelim(&cmdline, &size, 0 , fp);
fclose(fp);
return cmdline;
}
TEST(stdio, getdelim_invalid) {
FILE* fp = tmpfile();
ASSERT_TRUE(fp != NULL);
char* buffer = NULL;
size_t buffer_length = 0;
// The first argument can't be NULL.
errno = 0;
ASSERT_EQ(getdelim(NULL, &buffer_length, ' ', fp), -1);
ASSERT_EQ(EINVAL, errno);
// The second argument can't be NULL.
errno = 0;
ASSERT_EQ(getdelim(&buffer, NULL, ' ', fp), -1);
ASSERT_EQ(EINVAL, errno);
// The stream can't be closed.
fclose(fp);
errno = 0;
ASSERT_EQ(getdelim(&buffer, &buffer_length, ' ', fp), -1);
// glibc sometimes doesn't set errno in this particular case.
#if defined(__BIONIC__)
ASSERT_EQ(EBADF, errno);
#endif // __BIONIC__
}
TEST(stdio, getdelim) {
FILE* fp = tmpfile();
ASSERT_TRUE(fp != NULL);
const char* line_written = "This is a test";
int rc = fprintf(fp, "%s", line_written);
ASSERT_EQ(rc, static_cast<int>(strlen(line_written)));
rewind(fp);
char* word_read = NULL;
size_t allocated_length = 0;
const char* expected[] = { "This ", " ", "is ", "a ", "test" };
for (size_t i = 0; i < 5; ++i) {
ASSERT_FALSE(feof(fp));
ASSERT_EQ(getdelim(&word_read, &allocated_length, ' ', fp), static_cast<int>(strlen(expected[i])));
ASSERT_GE(allocated_length, strlen(expected[i]));
ASSERT_STREQ(word_read, expected[i]);
}
// The last read should have set the end-of-file indicator for the stream.
ASSERT_TRUE(feof(fp));
clearerr(fp);
// getdelim returns -1 but doesn't set errno if we're already at EOF.
// It should set the end-of-file indicator for the stream, though.
errno = 0;
ASSERT_EQ(getdelim(&word_read, &allocated_length, ' ', fp), -1);
ASSERT_EQ(errno, 0);
ASSERT_TRUE(feof(fp));
free(word_read);
fclose(fp);
}
int
main (int argc, char **argv)
{
FILE *f;
char *line = NULL;
size_t len = 0;
ssize_t result;
/* Create test file. */
f = fopen ("test-getdelim.txt", "wb");
if (!f || fwrite ("anbcnd\0f", 1, 8, f) != 8 || fclose (f) != 0)
{
fputs ("Failed to create sample file.\n", stderr);
remove ("test-getdelim.txt");
return 1;
}
f = fopen ("test-getdelim.txt", "rb");
if (!f)
{
fputs ("Failed to reopen sample file.\n", stderr);
remove ("test-getdelim.txt");
return 1;
}
/* Test initial allocation, which must include trailing NUL. */
result = getdelim (&line, &len, 'n', f);
ASSERT (result == 2);
ASSERT (strcmp (line, "an") == 0);
ASSERT (2 < len);
/* Test growth of buffer. */
free (line);
line = malloc (1);
len = 1;
result = getdelim (&line, &len, 'n', f);
ASSERT (result == 3);
ASSERT (strcmp (line, "bcn") == 0);
ASSERT (3 < len);
/* Test embedded NULs and EOF behavior. */
result = getdelim (&line, &len, 'n', f);
ASSERT (result == 3);
ASSERT (memcmp (line, "d\0f", 4) == 0);
ASSERT (3 < len);
result = getdelim (&line, &len, 'n', f);
ASSERT (result == -1);
free (line);
fclose (f);
remove ("test-getdelim.txt");
return 0;
}
int
lr_next (struct linereader *lr)
{
int n;
n = getdelim (&lr->buf, &lr->bufsize, '\n', lr->fp);
if (n < 0)
return -1;
++lr->lineno;
if (n > 1 && lr->buf[n - 2] == lr->escape_char && lr->buf[n - 1] == '\n')
{
#if 0
/* XXX Is this correct? */
/* An escaped newline character is substituted with a single <SP>. */
--n;
lr->buf[n - 1] = ' ';
#else
n -= 2;
#endif
}
lr->buf[n] = '\0';
lr->bufact = n;
lr->idx = 0;
return 0;
}
// ----------------------------------------------------------------
static int do_stream(char* file_name) {
FILE* input_stream = stdin;
FILE* output_stream = stdout;
if (strcmp(file_name, "-")) {
input_stream = fopen(file_name, "r");
if (input_stream == NULL) {
perror(file_name);
return 0;
}
}
while (1) {
char* line = NULL;
size_t linecap = 0;
ssize_t linelen = getdelim(&line, &linecap, '\n', input_stream);
if (linelen <= 0) {
break;
}
fputs(line, output_stream);
free(line);
}
if (input_stream != stdin)
fclose(input_stream);
return 1;
}
int main (int argc, char** argv) {
//FILE* fp = popen(FROM("/sys/devices") SELECT SUBSYSTEM("tty"), "r");
FILE* fp = popen(FROM("/sys/devices") SELECT SUBSYSTEM("usb") SELECTUP SUBSYSTEM("pci"), "r");
if (!fp) {
printf("popen() failed\n");
return 1;
}
char* device = NULL;
size_t n = 0;
while (-1 != getdelim(&device, &n, '\0', fp)) {
printf("%s\n", device);
}
free(device);
if (ferror(fp)) {
printf("error while reading\n");
return 1;
}
if (-1 == pclose(fp)) {
printf("pclose() failed\n");
return 1;
}
}
/*
* get_free_count - get number of free bytes on a node
*/
long long get_free_count(int node)
{
size_t len = 0;
char *line = NULL;
char fn[64];
long long size = -1;
FILE *f;
sprintf(fn, "/sys/devices/system/node/node%d/meminfo", node);
f = fopen(fn, "r");
if (!f)
return -1;
while (getdelim(&line, &len, '\n', f) > 0) {
char *end;
char *s = strstr(line, "kB");
if (!s)
continue;
--s;
while (s > line && isspace(*s))
--s;
while (s > line && isdigit(*s))
--s;
if (strstr(line, "MemFree")) {
size = strtoull(s, &end, 0) << 10;
if (end == s)
size = -1;
}
}
fclose(f);
free(line);
return size;
}
static int parse_arg(csiebox_client* client, int argc, char** argv) {
if (argc != 2) {
return 0;
}
FILE* file = fopen(argv[1], "r");
if (!file) {
return 0;
}
fprintf(stderr, "reading config...\n");
size_t keysize = 20, valsize = 20;
char* key = (char*)malloc(sizeof(char) * keysize);
char* val = (char*)malloc(sizeof(char) * valsize);
ssize_t keylen, vallen;
int accept_config_total = 5;
int accept_config[5] = {0, 0, 0, 0, 0};
while ((keylen = getdelim(&key, &keysize, '=', file) - 1) > 0) {
key[keylen] = '\0';
vallen = getline(&val, &valsize, file) - 1;
val[vallen] = '\0';
fprintf(stderr, "config (%zd, %s)=(%zd, %s)\n", keylen, key, vallen, val);
if (strcmp("name", key) == 0) {
if (vallen <= sizeof(client->arg.name)) {
strncpy(client->arg.name, val, vallen);
accept_config[0] = 1;
}
} else if (strcmp("server", key) == 0) {
if (vallen <= sizeof(client->arg.server)) {
strncpy(client->arg.server, val, vallen);
accept_config[1] = 1;
}
} else if (strcmp("user", key) == 0) {
if (vallen <= sizeof(client->arg.user)) {
strncpy(client->arg.user, val, vallen);
accept_config[2] = 1;
}
} else if (strcmp("passwd", key) == 0) {
if (vallen <= sizeof(client->arg.passwd)) {
strncpy(client->arg.passwd, val, vallen);
accept_config[3] = 1;
}
} else if (strcmp("path", key) == 0) {
if (vallen <= sizeof(client->arg.path)) {
strncpy(client->arg.path, val, vallen);
accept_config[4] = 1;
}
}
}
free(key);
free(val);
fclose(file);
int i, test = 1;
for (i = 0; i < accept_config_total; ++i) {
test = test & accept_config[i];
}
if (!test) {
fprintf(stderr, "config error\n");
return 0;
}
return 1;
}
/*
* get_largest_anon_set - return @pid's largest anonymous segment of memory
*/
int get_largest_anon_seg(int pid, void **va, unsigned long *ct)
{
size_t len = 0;
char *line = NULL;
char fn[64];
FILE *f;
unsigned long long size;
int ps = getpagesize();
*ct = 0;
sprintf(fn, "/proc/%d/numa_maps", pid);
f = fopen(fn, "r");
if (!f)
return -1;
while (getdelim(&line, &len, '\n', f) > 0) {
char *end;
char *s = strstr(line, "anon");
if (!s)
continue;
while (!isdigit(*s))
++s;
size = strtoull(s, &end, 0);
if (end == s)
size = 0;
if (size > *ct) {
*ct = size;
*va = (void *)strtoull(line, NULL, 16);
}
}
if (*ct == 0)
return -1;
return 0;
}
char *
argv_iter (struct argv_iterator *ai, enum argv_iter_err *err)
{
if (ai->fp)
{
ssize_t len = getdelim (&ai->tok, &ai->buf_len, '\0', ai->fp);
if (len < 0)
{
*err = feof (ai->fp) ? AI_ERR_EOF : AI_ERR_READ;
return NULL;
}
*err = AI_ERR_OK;
ai->item_idx++;
return ai->tok;
}
else
{
if (*(ai->p) == NULL)
{
*err = AI_ERR_EOF;
return NULL;
}
else
{
*err = AI_ERR_OK;
return *(ai->p++);
}
}
}
void getdatacommand::run()
{
FILE *fpipe;
char* line = 0;
size_t len = 0;
QString string;
if ( inRun != TRUE )
{
inRun = TRUE;
fpipe = popen(theQuery.toUtf8(), "r");
if(fpipe != NULL)
{
int findfile = 0;
// delimiter is null character.
while( getdelim(&line, &len, 0, fpipe) != -1 )
{
findfile++;
string = QString::fromUtf8(line);
theListBoxResults->addItem( string );
}
delete(line);
pclose(fpipe);
emit queryComplete(findfile);
}
inRun = FALSE;
}
}
bool files_parseDictionary(honggfuzz_t * hfuzz)
{
FILE *fDict = fopen(hfuzz->dictionaryFile, "rb");
if (fDict == NULL) {
PLOG_W("Couldn't open '%s' - R/O mode", hfuzz->dictionaryFile);
return false;
}
defer {
fclose(fDict);
};
for (;;) {
char *lineptr = NULL;
size_t n = 0;
ssize_t len = getdelim(&lineptr, &n, '\n', fDict);
if (len == -1) {
break;
}
if (n > 1 && lineptr[len - 1] == '\n') {
lineptr[len - 1] = '\0';
len--;
}
struct strings_t *str = (struct strings_t *)util_Malloc(sizeof(struct strings_t));
str->len = util_decodeCString(lineptr);
str->s = lineptr;
hfuzz->dictionaryCnt += 1;
TAILQ_INSERT_TAIL(&hfuzz->dictionaryq, str, pointers);
LOG_D("Dictionary: loaded word: '%s' (len=%zu)", str->s, str->len);
}
LOG_I("Loaded %zu words from the dictionary", hfuzz->dictionaryCnt);
return true;
}
TEST(stdio, getdelim_directory) {
FILE* fp = fopen("/proc", "r");
ASSERT_TRUE(fp != NULL);
char* word_read;
size_t allocated_length;
ASSERT_EQ(-1, getdelim(&word_read, &allocated_length, ' ', fp));
fclose(fp);
}
static int read_distance_table(void)
{
int nd, len;
char *line = NULL;
size_t linelen = 0;
int maxnode = numa_max_node() + 1;
int *table = NULL;
int err = -1;
for (nd = 0;; nd++) {
char fn[100];
FILE *dfh;
sprintf(fn, "/sys/devices/system/node/node%d/distance", nd);
dfh = fopen(fn, "r");
if (!dfh) {
if (errno == ENOENT)
err = 0;
if (!err && nd<maxnode)
continue;
else
break;
}
len = getdelim(&line, &linelen, '\n', dfh);
fclose(dfh);
if (len <= 0)
break;
if (!table) {
table = calloc(maxnode * maxnode, sizeof(int));
if (!table) {
errno = ENOMEM;
break;
}
}
parse_numbers(line, table + nd * maxnode);
}
free(line);
if (err) {
numa_warn(W_distance,
"Cannot parse distance information in sysfs: %s",
strerror(errno));
free(table);
return err;
}
/* Update the global table pointer. Race window here with
other threads, but in the worst case we leak one distance
array one time, which is tolerable. This avoids a
dependency on pthreads. */
if (distance_table) {
free(table);
return 0;
}
distance_numnodes = maxnode;
distance_table = table;
return 0;
}
static int parse_arg(csiebox_server* server, int argc, char** argv) {
if (argc < 2) {
return 0;
}
FILE* file = fopen(argv[1], "r");
if (!file) {
return 0;
}
fprintf(stderr, "reading config...\n");
size_t keysize = 20, valsize = 20;
char* key = (char*)malloc(sizeof(char) * keysize);
char* val = (char*)malloc(sizeof(char) * valsize);
ssize_t keylen, vallen;
int accept_config_total = 4;
int accept_config[4] = {0};
while ((keylen = getdelim(&key, &keysize, '=', file) - 1) > 0) {
key[keylen] = '\0';
vallen = getline(&val, &valsize, file) - 1;
val[vallen] = '\0';
fprintf(stderr, "config (%zd, %s)=(%zd, %s)\n", keylen, key, vallen, val);
if (strcmp("path", key) == 0) {
if (vallen <= sizeof(server->arg.path)) {
strncpy(server->arg.path, val, vallen);
accept_config[0] = 1;
}
} else if (strcmp("account_path", key) == 0) {
if (vallen <= sizeof(server->arg.account_path)) {
strncpy(server->arg.account_path, val, vallen);
accept_config[1] = 1;
}
} else if (strcmp("thread", key) == 0) {
server->arg.thread_max = atoi(val);
accept_config[2] = 1;
} else if (strcmp("run_path", key) == 0) {
if (vallen <= sizeof(server->arg.run_path)) {
strncpy(server->arg.run_path, val, vallen);
accept_config[3] = 1;
}
}
}
free(key);
free(val);
fclose(file);
int i, test = 1;
for (i = 0; i < accept_config_total; ++i) {
test = test & accept_config[i];
}
if (!test) {
fprintf(stderr, "config error\n");
return 0;
}
// daemonize
if (argc > 2 && strcmp(argv[2], "-d") == 0) server->arg.daemonize = 1;
else server->arg.daemonize = 0;
return 1;
}
int main(int, char**) {
ssize_t read;
char* line = NULL;
size_t len = 0;
while((read = getdelim(&line, &len, '\0', stdin)) != -1) {
puts(line);
}
free(line);
return 0;
}
void load_halos_from_file(char* fname, struct Catalogue *cat){
/*
Load catalogue of DM halos from specified file.
*/
int success;
char *buf = NULL;
size_t len;
FILE *f;
// Count number of rows in file
f = fopen(fname, "r");
cat->nhalos = 0;
while(getline(&buf, &len, f) != -1){
(cat->nhalos)++;
}
printf("Found %d halos in %s.\n", cat->nhalos, fname);
rewind(f); // Return to start of file
// Allocate halo arrays
cat->mhalo = malloc(sizeof(float) * (cat->nhalos));
cat->z = malloc(sizeof(float) * (cat->nhalos));
// Load catalogue into arrays (assumes only two columns, space-separated)
for(int i=0; i < cat->nhalos; i++){
// Halo mass (column 0)
success = getdelim(&buf, &len, ' ', f);
if(success){
(cat->mhalo)[i] = strtof(buf, NULL);
}
// Redshift (column 1)
success = getdelim(&buf, &len, '\n', f);
if(success){
(cat->z)[i] = strtof(buf, NULL);
}
}
// Close file and free buffers
free(buf);
fclose(f);
}
TEST(stdio, getdelim_invalid) {
FILE* fp = tmpfile();
char* buffer = NULL;
size_t buffer_length = 0;
// The first argument can't be NULL.
errno = 0;
ASSERT_EQ(getdelim(NULL, &buffer_length, ' ', fp), -1);
ASSERT_EQ(errno, EINVAL);
// The second argument can't be NULL.
errno = 0;
ASSERT_EQ(getdelim(&buffer, NULL, ' ', fp), -1);
ASSERT_EQ(errno, EINVAL);
// The stream can't be closed.
fclose(fp);
errno = 0;
ASSERT_EQ(getdelim(&buffer, &buffer_length, ' ', fp), -1);
ASSERT_EQ(errno, EBADF);
}
I getdelim_(S *s,I *n,I d,FILE *f)
{
I m; S z;size_t o=*n;
if(getdelim(s,&o,d,f)==-1){*n=0; R -1;}
*n=o;
m=strlenn(*s,*n);
if(1<m && '\n'==(*s)[m-1] && '\r'==(*s)[m-2]) {
(*s)[--m]='\0'; (*s)[m-1]='\n'; }
z=strdupn(*s,m);
free(*s);
*s=z;
R *n=m;
}
// ----------------------------------------------------------------
char* mlr_get_line(FILE* input_stream, char rs) {
char* line = NULL;
size_t linecap = 0;
ssize_t linelen = getdelim(&line, &linecap, rs, input_stream);
if (linelen <= 0) {
return NULL;
}
if (line[linelen-1] == '\n') { // chomp
line[linelen-1] = 0;
linelen--;
}
return line;
}
void readconf (void)
{
char *line;
size_t linel;
int linenum;
FILE *ifh;
char *p;
int n;
ifh = fopen (fname, "r");
if (!ifh)
complain (_("opening configuration file %s: %s"), fname, strerror (errno));
line = NULL;
linel = 0;
linenum = 1;
while (getdelim (&line, &linel, '\n', ifh) > 0)
{
struct change *ch = xmalloc (sizeof (struct change));
char pos[20];
sprintf (pos, _("line %d"), linenum);
if ((p = strchr (line, '#')) != NULL)
*p = '\0';
p = line;
while (isspace (*p))
++p;
if (*p == '\0')
continue;
n = strcspn (p, " \t");
if (n > IFNAMSIZ)
complain (_("interface name too long at line %d"), line);
memcpy (ch->ifname, p, n);
ch->ifname[n] = 0;
p += n;
p += strspn (p, " \t");
n = strspn (p, "0123456789ABCDEFabcdef:");
p[n] = 0;
addchange (p, ch, pos);
linenum++;
}
fclose (ifh);
}
// ----------------------------------------------------------------
char* mlr_get_cline(FILE* fp, char irs) {
char* line = NULL;
size_t linecap = 0;
ssize_t linelen = getdelim(&line, &linecap, irs, fp);
if (linelen <= 0) {
return NULL;
}
if (line[linelen-1] == '\n') { // chomp
line[linelen-1] = 0;
linelen--;
}
return line;
}
int test_getdelim()
{
char buf[BUF_SIZE];
FILE *f;
int rc;
int i;
if (make_test_file(DATA_2, LINE_NUM_2) != 0) {
printf("test_getdelim: failed to make test file\n");
return 1;
}
f = fopen(TEST_FILE_NAME, "r");
if (f == NULL) {
rc = errno;
printf("test_getdelim: failed to open temp file; error %i; %s\n", rc, strerror(rc));
return 1;
}
for (i=0; i<LINE_NUM_2; ++i) {
char *s = NULL;
int num = 0;
if (getdelim(&s, &num, ' ', f) == -1) {
rc = errno;
printf("test_getdelim: failed to read temp file; error %i; %s\n", rc, strerror(rc));
return 1;
}
if (strcmp(s, DATA_2[i]) != 0) {
printf("test_getdelim: expected: '%s'\n", DATA_2[i]);
printf("test_getdelim: read: '%s'\n", s);
return 1;
}
}
if (fclose(f) != 0) {
rc = errno;
printf("failed to close test file; error %i; %s\n", rc, strerror(rc));
return 1;
}
if (unlink(TEST_FILE_NAME) != 0) {
rc = errno;
printf("failed to close test file; error %i; %s\n", rc, strerror(rc));
return 1;
}
printf("getdelim - ok\n");
return 0;
}
TEST(stdio, getdelim_invalid) {
FILE* fp = tmpfile();
ASSERT_TRUE(fp != NULL);
char* buffer = NULL;
size_t buffer_length = 0;
// The first argument can't be NULL.
errno = 0;
ASSERT_EQ(getdelim(NULL, &buffer_length, ' ', fp), -1);
ASSERT_EQ(EINVAL, errno);
// The second argument can't be NULL.
errno = 0;
ASSERT_EQ(getdelim(&buffer, NULL, ' ', fp), -1);
ASSERT_EQ(EINVAL, errno);
// The underlying fd can't be closed.
ASSERT_EQ(0, close(fileno(fp)));
errno = 0;
ASSERT_EQ(getdelim(&buffer, &buffer_length, ' ', fp), -1);
ASSERT_EQ(EBADF, errno);
fclose(fp);
}
ssize_t mygetline(char **lineptr, size_t * n, FILE * stream)
{
ssize_t mread;
char *line = NULL;
char *head = NULL;
line = *lineptr;
if ((mread = getline(&line, n, stream)) > 0) {
head = line;
line = line + mread - 1;
if (head[0] == '\n') {
*lineptr = head;
return mread;
}
if (head[0] == '.' && head[1] == 'q') {
return -1;
}
if (head[0] == '.' && head[1] == 'e') {
return -1;
}
if (strcspn(head, ";") < (size_t) mread) {
*lineptr = head;
return mread;
}
if ((mread = getdelim(&line, n, ';', stream)) < 0) {
fprintf(stderr, "ERROR in mygetline getdelm \n");
}
}
*lineptr = head;
return mread;
}
ssize_t apol_getline(char **lineptr, size_t *n, FILE *stream)
{
#ifdef __ANDROID__
char *ptr;
size_t len;
if (lineptr == NULL || n == NULL) {
errno = EINVAL;
return -1;
}
ptr = fgetln(stream, n);
if (ptr == NULL) {
return -1;
}
/* Free the original ptr */
if (*lineptr != NULL) free(*lineptr);
/* Add one more space for '\0' */
len = n[0] + 1;
/* Update the length */
n[0] = len;
/* Allocate a new buffer */
*lineptr = malloc(len);
if (*lineptr == NULL) {
errno = ENOMEM;
return -1;
}
/* Copy over the string */
memcpy(*lineptr, ptr, len-1);
/* Write the NULL character */
(*lineptr)[len-1] = '\0';
/* Return the length of the new buffer */
return (ssize_t)len;
#else /* __ANDROID__ */
return getdelim(lineptr, n, '\n', stream);
#endif /* __ANDROID__ */
}
int main (int argc, char ** argv)
{
FILE * cpuinfo = fopen("/proc/cpuinfo", "rb");
char * arg = 0;
size_t size = 0;
if (!cpuinfo)
return errno;
while(getdelim(&arg, &size, 0, cpuinfo) != -1)
puts(arg);
free(arg);
fclose(cpuinfo);
return 0;
}
static int _cs_analyze_content( struct state *s ) {
if( s->analysis->utf8[0] == s->final_line_separator /* we've finished another line */ ) {
ssize_t llen;
s->lines ++;
rewind( s->cache );
if( (llen = getdelim( &_line, &_blen, s->final_line_separator, s->cache )) > 0 )
_analyze_line( s->analysis, _line, llen ); // ...whether empty or not!
rewind( s->cache );
}
return ASTAT_CONTINUE;
}
static int
handle_existing_file(char **path)
{
size_t alen;
ssize_t len;
char buf[4];
for (;;) {
fprintf(stderr,
"replace %s? [y]es, [n]o, [A]ll, [N]one, [r]ename: ",
*path);
if (fgets(buf, sizeof(buf), stdin) == NULL) {
clearerr(stdin);
printf("NULL\n(EOF or read error, "
"treating as \"[N]one\"...)\n");
n_opt = 1;
return -1;
}
switch (*buf) {
case 'A':
o_opt = 1;
/* FALLTHROUGH */
case 'y':
case 'Y':
(void)unlink(*path);
return 1;
case 'N':
n_opt = 1;
/* FALLTHROUGH */
case 'n':
return -1;
case 'r':
case 'R':
printf("New name: ");
fflush(stdout);
free(*path);
*path = NULL;
alen = 0;
len = getdelim(path, &alen, '\n', stdin);
if ((*path)[len - 1] == '\n')
(*path)[len - 1] = '\0';
return 0;
default:
break;
}
}
}
