static void stest_status_files_init(void)
{
char percent_fname[PATH_MAX], err_fname[PATH_MAX];
if (zsnprintf(percent_fname, sizeof(percent_fname),
"%s/percent", g_test_dir)) {
fprintf(stderr, "tempdir name too long!\n");
exit(EXIT_FAILURE);
}
g_percent_fd = open(percent_fname, O_WRONLY | O_TRUNC | O_CREAT, 0640);
if (g_percent_fd < 0) {
int ret = errno;
fprintf(stderr, "failed to open '%s': error %d\n",
percent_fname, ret);
exit(EXIT_FAILURE);
}
if (zsnprintf(err_fname, sizeof(err_fname),
"%s/err", g_test_dir)) {
fprintf(stderr, "tempdir name too long!\n");
exit(EXIT_FAILURE);
}
g_err_fp = fopen(err_fname, "w");
if (g_err_fp == NULL) {
int ret = errno;
fprintf(stderr, "failed to open '%s': error %d\n",
err_fname, ret);
exit(EXIT_FAILURE);
}
stest_set_status(0);
}
int canon_path_add_suffix(char *base, size_t out_len, char suffix)
{
size_t cbase_len;
cbase_len = strlen(base);
if (cbase_len < 2)
return zsnprintf(base, out_len, "%c", suffix);
return zsnprintf(base + cbase_len, out_len - cbase_len, "%c", suffix);
}
int do_basename(char *bname, size_t bname_len, const char *fname)
{
char *base;
base = strrchr(fname, '/');
if (!base) {
return zsnprintf(bname, bname_len, "%s", fname);
}
return zsnprintf(bname, bname_len, "%s", base + 1);
}
int canon_path_append(char *base, size_t out_len, const char *suffix)
{
size_t cbase_len;
if (!suffix[0])
return 0;
cbase_len = strlen(base);
if (cbase_len < 2)
return zsnprintf(base, out_len, "/%s", suffix);
return zsnprintf(base + cbase_len, out_len - cbase_len, "/%s", suffix);
}
/* A simple test of what POSIX rename does in a bunch of different
* scenarios. This doesn't test certain tricky corner cases like a rename
* where both src and dst are a hardlink to the same file. It's just your
* basic directories and files.
*/
static int do_rename(const char *src_base, const char *src_suffix,
const char *dst_base, const char *dst_suffix)
{
char src[PATH_MAX], dst[PATH_MAX];
EXPECT_ZERO(zsnprintf(src, PATH_MAX, "%s/%s", src_base, src_suffix));
EXPECT_ZERO(zsnprintf(dst, PATH_MAX, "%s/%s", dst_base, dst_suffix));
if (rename(src, dst) < 0) {
int err = -errno;
return err;
}
return 0;
}
static int test_copy_fd_to_fd(const char *tempdir, int *next_id,
const char *buf)
{
size_t buf_len = strlen(buf);
ssize_t res;
char *nbuf, src_file[PATH_MAX], dst_file[PATH_MAX];
FILE *ifp, *ofp;
int ret;
EXPECT_ZERO(zsnprintf(src_file, sizeof(src_file),
"%s/src_file.%d", tempdir, *next_id));
EXPECT_ZERO(zsnprintf(dst_file, sizeof(dst_file),
"%s/dst_file.%d", tempdir, *next_id));
*next_id = *next_id + 1;
ifp = fopen(src_file, "w");
if (!ifp) {
ret = errno;
return ret;
}
EXPECT_EQUAL(fwrite(buf, 1, buf_len, ifp), buf_len);
ifp = freopen(src_file, "r", ifp);
if (!ifp) {
ret = errno;
return ret;
}
ofp = fopen(dst_file, "w");
if (!ofp) {
ret = errno;
fclose(ifp);
return ret;
}
ret = copy_fd_to_fd(fileno(ifp), fileno(ofp));
EXPECT_ZERO(ret);
fclose(ofp);
fclose(ifp);
nbuf = calloc(1, buf_len + 1);
EXPECT_NOT_EQUAL(nbuf, NULL);
res = simple_io_read_whole_file_zt(dst_file, nbuf, buf_len + 1);
if (res < 0) {
free(nbuf);
return res;
}
if ((res > 0) && (memcmp(buf, nbuf, buf_len - 1))) {
free(nbuf);
return -EIO;
}
free(nbuf);
return 0;
}
void
snmp_progname_set ()
{
char buf[50];
zsnprintf (snmp_progname, 100, "bgpsdn-%s", bgpsdn_version (buf, 50));
}
int at_cmgd(int index, int mode) {
char buffer[256];
zsnprintf(buffer, "AT+CMGD=%d,%d", index, mode);
writefd(buffer);
return checkok();
}
int at_curc(int value) {
char buffer[256];
zsnprintf(buffer, "AT^CURC=%d", value);
writefd(buffer);
return checkok();
}
int at_cmgl(char *mode) {
char buffer[256];
zsnprintf(buffer, "AT+CMGL=%s", mode);
writefd(buffer);
return 1;
}
int at_cnmi(int mode, int i1, int i2, int i3, int i4) {
char buffer[256];
zsnprintf(buffer, "AT+CNMI=%d,%d,%d,%d,%d", mode, i1, i2, i3, i4);
writefd(buffer);
return checkok();
}
int at_cpms(char *s1, char *s2, char *s3) {
char buffer[256];
zsnprintf(buffer, "AT+CPMS=\"%s\",\"%s\",\"%s\"", s1, s2, s3);
writefd(buffer);
return checkok();
}
int at_cmgf(int mode) {
char buffer[256];
zsnprintf(buffer, "AT+CMGF=%d", mode);
writefd(buffer);
return checkok();
}
int at_echo(int value) {
char buffer[64];
zsnprintf(buffer, "ATE%d", value);
writefd(buffer);
return checkok();
}
static int do_test_mkdir(const char *base, const char *suffix)
{
char path[PATH_MAX];
EXPECT_ZERO(zsnprintf(path, PATH_MAX, "%s/%s", base, suffix));
if (mkdir(path, 0755) < 0) {
return -errno;
}
return 0;
}
static int test_canonicalize_path(const char *path, const char *expected)
{
char epath[PATH_MAX];
EXPECT_ZERO(zsnprintf(epath, PATH_MAX, "%s", path));
if (!expected) {
EXPECT_NONZERO(canonicalize_path(epath));
}
else {
EXPECT_ZERO(canonicalize_path(epath));
EXPECT_ZERO(strcmp(epath, expected));
}
return 0;
}
static void stest_output_start_msg(void)
{
int ret;
char start_msg[512];
if (zsnprintf(start_msg, sizeof(start_msg), "STEST_STARTED: %s\n",
g_test_dir)) {
fprintf(stderr, "start_msg buffer too short!\n");
exit(EXIT_FAILURE);
}
ret = safe_write(STDOUT_FILENO, start_msg, strlen(start_msg));
if (ret) {
fprintf(stderr, "safe_write to stdout failed with error %d",
ret);
exit(EXIT_FAILURE);
}
}
static int read_then_write_file(const char *tempdir, int *next_id,
const char *contents, int buf_sz)
{
ssize_t res;
FILE *fp;
char *buf, file_name[PATH_MAX];
EXPECT_ZERO(zsnprintf(file_name, PATH_MAX,"%s/outfile.%d",
tempdir, *next_id));
*next_id = *next_id + 1;
fp = fopen(file_name, "w");
if (!fp) {
int ret = errno;
fprintf(stderr, "failed to open '%s': error %d\n",
file_name, ret);
return ret;
}
if (fprintf(fp, "%s", contents) < 0) {
int ret = errno;
fprintf(stderr, "failed to write to '%s': error %d\n",
file_name, ret);
return ret;
}
EXPECT_ZERO(fclose(fp));
buf = calloc(1, buf_sz);
if (!buf) {
return -ENOMEM;
}
res = simple_io_read_whole_file_zt(file_name, buf, buf_sz);
if (res < 0) {
free(buf);
fprintf(stderr, "simple_io_read_whole_file_zt failed with "
"error %Zd\n", res);
return res;
}
if ((buf_sz > 0) && (strncmp(contents, buf, buf_sz - 1))) {
fprintf(stderr, "got contents: '%s'; expected first "
"%d characters of: '%s' \n",
buf, buf_sz - 1, contents);
free(buf);
return -EIO;
}
free(buf);
return 0;
}
static int keymaster_readdir(const char *path, void *buf,
fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi) {
int ret;
DIR *dp;
struct dirent *de;
struct stat st;
const char *p;
char kpath[PATH_MAX];
fprintf(stderr, "keymaster_readdir(path = '%s')\n", path);
dp = opendir(KRB5CC_PREFIX_DIRNAME);
if (!dp)
return -errno;
while ((de = readdir(dp))) {
if (strncmp(de->d_name, KRB5CC_PREFIX, KRB5CC_PREFIX_LEN)) {
continue;
}
p = de->d_name + KRB5CC_PREFIX_LEN;
if (strspn(p, "0123456789") != strlen(p)) {
continue;
}
memset(&st, 0, sizeof(st));
if (zsnprintf(kpath, sizeof(kpath),
KRB5CC_PREFIX_DIRNAME "%s", de->d_name)) {
continue;
}
ret = stat(kpath, &st);
if (ret) {
continue;
}
if (filler(buf, p, &st, 0)) {
break;
}
}
closedir(dp);
return 0;
}
static int uid_to_kpath(uid_t uid, char *out, size_t out_len) {
return zsnprintf(out, out_len, KRB5CC_FULL_PREFIX "%d", uid);
}
void periodic_whatcd(list_t *tracking) {
whatcd_t *whatcd;
list_node_t *node2;
whatcd_request_t *request;
whatcd_release_t *release;
char buffer[2048], *output;
list_t *users;
int *trackval; /* store value for check how many errors/users waz */
if(!(users = settings_by_key("whatsession", PRIVATE)))
return;
list_foreach(users, node) {
whatcd = whatcd_new((char *) node->data);
/* load error count */
if(!(trackval = (int *) list_search(tracking, node->name))) {
trackval = (int *) calloc(1, sizeof(int));
list_append(tracking, node->name, trackval);
}
if(!(output = settings_get(node->name, "whatchan", PUBLIC)))
output = node->name;
/* notification failed */
if(!(request = whatcd_notification(whatcd))) {
printf("[-] periodic/whatcd: trackval error count for %s: %d\n", node->name, ++*trackval);
if(*trackval == 4)
irc_notice(node->name, "cannot grab your notifications, please check your whatcd session");
if(*trackval == 50)
irc_notice(node->name, "whatcd session seems really down, please check your whatcd session or unset it with: .unset whatsession");
goto next_node;
}
if(request->error) {
printf("[-] periodic/whatcd: error: %s\n", request->error);
goto next_node;
}
node2 = request->response->nodes;
while(node2) {
release = (whatcd_release_t *) node2->data;
node2 = node2->next;
if(!release->unread)
continue;
zsnprintf(buffer,
"%s: [%s/%s] %s - %s (%.2f Mo): " WHATCD_TORRENT "%.0f&torrentid=%.0f",
node->name,
release->format, release->media, release->artist, release->groupname,
release->size / 1024 / 1024, release->groupid,
release->torrentid
);
irc_privmsg(output, buffer);
*trackval = 0;
}
next_node:
whatcd_request_free(request);
whatcd_free(whatcd);
}
