Back to index

im-sdk  12.3.91
Defines | Functions
role-data-client.c File Reference
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <time.h>
#include <pwd.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/utsname.h>
#include <iiimp.h>
#include "input-method.h"
#include "role-data-client.h"

Go to the source code of this file.

Defines

#define NODE_DEFAULT   "localhost"
#define NODE_KEY   "node="
#define NODE_KEY_LEN   (5)
#define SERVICE_DEFAULT   "9010"
#define SERVICE_KEY   "service="
#define SERVICE_KEY_LEN   (8)
#define SERVER_FILE   ".iiim/server"
#define SERVER_FILE_LEN   (12)
#define SERVER_COMPAT_FILE   ".iiimp"
#define SERVER_COMPAT_FILE_LEN   (6)
#define SERVER_COMPAT_KEY   "iiimp.server=iiimp://"
#define SERVER_COMPAT_KEY_LEN   (21)
#define CONFIG_DIR_BASE   ".iiim"
#define CONFIG_DIR_AUTH   ".iiim/auth"
#define CONFIG_FILE_PASSWD   ".iiim/auth/passwd"
#define PASSWORD_FILE_LEN   (17)
#define AUTH_PASSWORD_LEN   (32)
#define HOME_ENV   "HOME"
#define IIIM_SERVER_ENV   "IIIM_SERVER"
#define CLIENT_TYPE   "generic IIIMP client"
#define POSITION_HEAD(p, n)
#define POSITION_TAIL(p, n)
#define POSITION_TAIL_COMPAT(p, n)

Functions

const char * iiimf_role_data_client_user_name (IIIMF_im *im)
const char * iiimf_role_data_client_home_dir (IIIMF_im *im)
const char * iiimf_role_data_client_node (IIIMF_im *im)
const char * iiimf_role_data_client_server_node (IIIMF_im *im)
const char * iiimf_role_data_client_service (IIIMF_im *im)
static IIIMF_status get_param (const char **buf, size_t *nbyte, const char *key, size_t key_len, char **param_ret)
static IIIMF_status get_param_compat (const char **buf, size_t *nbyte, const char *key, size_t key_len, char **param_ret)
static IIIMF_status iiimf_role_data_client_file_server (IIIMF_role_data_client *client)
static IIIMF_status iiimf_role_data_client_file_compat_server (IIIMF_role_data_client *client)
static IIIMF_status iiimf_role_data_client_environ_server (IIIMF_role_data_client *client)
IIIMF_status iiimf_im_client_type_set (IIIMF_im *im, const char *type)
IIIMF_status iiimf_im_user_set (IIIMF_im *im, const char *username, const char *password)
IIIMF_status iiimf_role_data_client_new (const char *server_node, const char *service, IIIMF_role_data_client **client_ret)
void iiimf_role_data_client_delete (IIIMF_role_data_client *client)
static void auth_password_generate (char *password, size_t length)
static int auth_password_file_init (char *password_file, size_t home_dir_len)
static int auth_password_file_open (const char *home_dir)
IIIMF_status iiimf_role_data_client_auth_password (IIIMF_im *im, char **password_ret)

Define Documentation

#define AUTH_PASSWORD_LEN   (32)

Definition at line 43 of file role-data-client.c.

#define CLIENT_TYPE   "generic IIIMP client"

Definition at line 47 of file role-data-client.c.

#define CONFIG_DIR_AUTH   ".iiim/auth"

Definition at line 40 of file role-data-client.c.

#define CONFIG_DIR_BASE   ".iiim"

Definition at line 39 of file role-data-client.c.

#define CONFIG_FILE_PASSWD   ".iiim/auth/passwd"

Definition at line 41 of file role-data-client.c.

#define HOME_ENV   "HOME"

Definition at line 44 of file role-data-client.c.

#define IIIM_SERVER_ENV   "IIIM_SERVER"

Definition at line 45 of file role-data-client.c.

#define NODE_DEFAULT   "localhost"

Definition at line 24 of file role-data-client.c.

#define NODE_KEY   "node="

Definition at line 25 of file role-data-client.c.

#define NODE_KEY_LEN   (5)

Definition at line 26 of file role-data-client.c.

#define PASSWORD_FILE_LEN   (17)

Definition at line 42 of file role-data-client.c.

#define POSITION_HEAD (   p,
 
)
Value:
for (; 0 < n; --(n), (p)++) { \
              if ((' ' != *(p)) && ('\t' != *(p)) && \
                  ('\r' != *(p)) && ('\n' != *(p))) { \
                     break; \
              } \
       } \
       if ((0 < (n)) && ((',' == *(p)) || (';' == *(p)))) { \
              --(n); \
              (p)++; \
       } \
       for (; 0 < n; --(n), (p)++) { \
              if ((' ' != *(p)) && ('\t' != *(p)) && \
                  ('\r' != *(p)) && ('\n' != *(p))) { \
                     break; \
              } \
       }

Definition at line 85 of file role-data-client.c.

#define POSITION_TAIL (   p,
 
)
Value:
for (; 0 < n; --(n), (p)++) { \
              if ((',' == *(p)) || (';' == *(p)) || \
                  (' ' == *(p)) || ('\t' == *(p)) || \
                  ('\r' == *(p)) || ('\n' == *(p))) { \
                     break; \
              } \
       }

Definition at line 103 of file role-data-client.c.

#define POSITION_TAIL_COMPAT (   p,
 
)
Value:
for (; 0 < n; --(n), (p)++) { \
              if ((':' == *(p)) || ('\r' == *(p)) || ('\n' == *(p))) { \
                     break; \
              } \
       }

Definition at line 112 of file role-data-client.c.

#define SERVER_COMPAT_FILE   ".iiimp"

Definition at line 34 of file role-data-client.c.

#define SERVER_COMPAT_FILE_LEN   (6)

Definition at line 35 of file role-data-client.c.

#define SERVER_COMPAT_KEY   "iiimp.server=iiimp://"

Definition at line 36 of file role-data-client.c.

#define SERVER_COMPAT_KEY_LEN   (21)

Definition at line 37 of file role-data-client.c.

#define SERVER_FILE   ".iiim/server"

Definition at line 31 of file role-data-client.c.

#define SERVER_FILE_LEN   (12)

Definition at line 32 of file role-data-client.c.

#define SERVICE_DEFAULT   "9010"

Definition at line 27 of file role-data-client.c.

#define SERVICE_KEY   "service="

Definition at line 28 of file role-data-client.c.

#define SERVICE_KEY_LEN   (8)

Definition at line 29 of file role-data-client.c.


Function Documentation

static int auth_password_file_init ( char *  password_file,
size_t  home_dir_len 
) [static]

Definition at line 612 of file role-data-client.c.

{
    int              fd;
    char      pwd_buf[AUTH_PASSWORD_LEN + 1];
    struct stat      st;
    ssize_t   len;

    /* ${HOME}/.iiim */
    (void)strcpy(password_file + home_dir_len, CONFIG_DIR_BASE);
    if (0 != stat(password_file, &st)) {
       if (ENOENT != errno) return -1;
       if (0 != mkdir(password_file, 0777)) return -1;
    }

    /* ${HOME}/.iiim/auth */
    (void)strcpy(password_file + home_dir_len, CONFIG_DIR_AUTH);
    if (0 != stat(password_file, &st)) {
       if (ENOENT != errno) return -1;
       if (0 != mkdir(password_file, 0700)) return -1;
    }

    /* ${HOME}/.iiim/auth/password */
    (void)strcpy(password_file + home_dir_len, CONFIG_FILE_PASSWD);
    fd = open(password_file, O_CREAT | O_WRONLY, 0600);
    if (-1 == fd) return -1;

    auth_password_generate(pwd_buf, AUTH_PASSWORD_LEN);

    len = write(fd, pwd_buf, AUTH_PASSWORD_LEN + 1);
    (void)close(fd);

    if ((AUTH_PASSWORD_LEN + 1) == len) {
       return 0;
    } else {
       return -1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int auth_password_file_open ( const char *  home_dir) [static]

Definition at line 652 of file role-data-client.c.

{
    char *    password_file;
    char *    home_env;
    int              home_dir_len;
    int              len;
    struct stat      st;
    int              fd;

    password_file = NULL;

    if (NULL == home_dir) {
       home_env = getenv("HOME");
       if (NULL != home_env) {
           home_dir = home_env;
       }
       if (NULL == home_dir) {
           return -1;
       }
    }

    home_dir_len = strlen(home_dir);
    len = (home_dir_len + 1 + PASSWORD_FILE_LEN);

    password_file = malloc(len + 1);
    if (NULL == password_file) {
       return -1;
    }

    (void)strcpy(password_file, home_dir);
    *(password_file + home_dir_len) = '/';
    home_dir_len += 1;
    (void)strcpy(password_file + home_dir_len, CONFIG_FILE_PASSWD);

    if (0 != stat(password_file, &st)) {
       (void)auth_password_file_init(password_file, home_dir_len);
    }

    fd = open(password_file, O_RDONLY, 0);
    free(password_file);

    return fd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void auth_password_generate ( char *  password,
size_t  length 
) [static]

Definition at line 567 of file role-data-client.c.

{
    int                     fd;
    unsigned int     seed;
    int                     c;
    int                     i;
    int                     r;
    unsigned int *   p;
    size_t           n;
    char *           c62;

    *(password + length) = '\0';

    c62 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    fd = open("/dev/random", O_RDONLY, 0);
    if (0 <= fd) {
       r = 0;
       n = ((sizeof (unsigned int)) * length);
       p = (unsigned int * )malloc(n);
       if (NULL != p) {
           r = read(fd, p, n);
       }
       (void)close(fd);
       if (r == length) {
           for (i = 0; i < length; i++) {
              *(password + i) = *(c62 + (*(p + i) % 62));
           }
           free(p);
           return;
       }
       free(p);
    }

    seed = (time(NULL) + getpid());
    srand(seed);
    for (i = 0; i < length; i++) {
       c = rand();
       *(password + i) = *(c62 + (c % 62));
    }

    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static IIIMF_status get_param ( const char **  buf,
size_t *  nbyte,
const char *  key,
size_t  key_len,
char **  param_ret 
) [static]

Definition at line 121 of file role-data-client.c.

{
    const char *     b;
    const char *     p;
    size_t           n;
    size_t           m;
    size_t           len;
    char *           param;

    b = *buf;
    n = *nbyte;

    if (n < key_len) return IIIMF_STATUS_CONFIG;

    if (0 != strncasecmp(b, key, key_len)) {
       return IIIMF_STATUS_CONFIG;
    }

    b += key_len;
    n -= key_len;
    p = b;
    m = n;

    POSITION_TAIL(b, n);

    len = (m - n);

    param = (char *)malloc(len + 1);
    if (NULL == param) return IIIMF_STATUS_MALLOC;

    (void)memcpy(param, p, len);
    *(param + len) = '\0';

    *buf = b;
    *nbyte = n;
    *param_ret = param;

    return IIIMF_STATUS_SUCCESS;
}

Here is the caller graph for this function:

static IIIMF_status get_param_compat ( const char **  buf,
size_t *  nbyte,
const char *  key,
size_t  key_len,
char **  param_ret 
) [static]

Definition at line 168 of file role-data-client.c.

{
    const char *     b;
    const char *     p;
    size_t           n;
    size_t           m;
    size_t           len;
    char *           param;

    b = *buf;
    n = *nbyte;

    if (n < key_len) return IIIMF_STATUS_CONFIG;

    if (0 != strncasecmp(b, key, key_len)) {
       return IIIMF_STATUS_CONFIG;
    }

    b += key_len;
    n -= key_len;
    p = b;
    m = n;

    POSITION_TAIL_COMPAT(b, n);

    len = (m - n);

    param = (char *)malloc(len + 1);
    if (NULL == param) return IIIMF_STATUS_MALLOC;

    (void)memcpy(param, p, len);
    *(param + len) = '\0';

    *buf = b;
    *nbyte = n;
    *param_ret = param;

    return IIIMF_STATUS_SUCCESS;
}

Here is the caller graph for this function:

IIIMF_status iiimf_im_client_type_set ( IIIMF_im *  im,
const char *  type 
)

Definition at line 405 of file role-data-client.c.

{
    char *    p;
    p = strdup(type);
    if (NULL == p) return IIIMF_STATUS_MALLOC;
    free(im->role_data.client->type);
    im->role_data.client->type = p;
    return IIIMF_STATUS_SUCCESS;
}
IIIMF_status iiimf_im_user_set ( IIIMF_im *  im,
const char *  username,
const char *  password 
)

Definition at line 418 of file role-data-client.c.

{
    IIIMF_role_data_client *       client;

    client = im->role_data.client;
    if (username) {
       if (client->user_name) free(client->user_name);
       client->user_name = strdup(username);
    }
    if (password) {
       if (client->password) free(client->password);
       client->password = strdup(password);
    }

    return IIIMF_STATUS_SUCCESS;
}
IIIMF_status iiimf_role_data_client_auth_password ( IIIMF_im *  im,
char **  password_ret 
)

Definition at line 698 of file role-data-client.c.

{

#if 0
    char *    password;
    int              fd;
    int              len;
    int              i;
    char      pwd_buf[AUTH_PASSWORD_LEN + 1];

    if (im->role_data.client->password) {
       *password_ret = strdup(im->role_data.client->password);
       if (!(*password_ret)) return IIIMF_STATUS_MALLOC;
    } else {
       password = NULL;
       fd = -1;

       fd = auth_password_file_open(im->role_data.client->home_dir);
       if (-1 == fd) return IIIMF_STATUS_CONFIG;

       len = read(fd, pwd_buf, AUTH_PASSWORD_LEN);
       (void)close(fd);

       if (AUTH_PASSWORD_LEN != len) return IIIMF_STATUS_CONFIG;

       for (i = 0; i < AUTH_PASSWORD_LEN; i++) {
           if (0 == isalnum(pwd_buf[i])) {
              return IIIMF_STATUS_CONFIG;
           }
       }
       if (AUTH_PASSWORD_LEN != i) {
           return IIIMF_STATUS_CONFIG;
       }

       password = malloc(AUTH_PASSWORD_LEN + 1);
       if (NULL == password) return IIIMF_STATUS_MALLOC;
       (void)memcpy(password, pwd_buf, AUTH_PASSWORD_LEN);
       *(password + AUTH_PASSWORD_LEN) = '\0';

       *password_ret = password;
    }

#endif
    *password_ret = strdup("");
    return IIIMF_STATUS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 547 of file role-data-client.c.

{
    if (client->user_name) free(client->user_name);
    if (client->password) free(client->password);
    if (client->home_dir) free(client->home_dir);
    if (client->node) free(client->node);
    if (client->server_node) free(client->server_node);
    if (client->service) free(client->service);
    if (client->type) free(client->type);
    if (client->os_name) free(client->os_name);
    if (client->os_arch) free(client->os_arch);
    if (client->os_version) free(client->os_version);
    if (client->X_display_name) free(client->X_display_name);
    if (client->X_server_vendor) free(client->X_server_vendor);

    free(client);
}

Here is the caller graph for this function:

Definition at line 374 of file role-data-client.c.

{
    IIIMF_status     status;
    const char *     p;
    size_t           rest;
    char *           node;
    char *           service;

    p = getenv(IIIM_SERVER_ENV);
    if (NULL == p) return IIIMF_STATUS_FAIL;

    rest = strlen(p);

    status = get_param(&p, &rest, "", 0, &node);
    if (IIIMF_STATUS_SUCCESS != status) {
       return status;
    }

    client->server_node = node;

    POSITION_HEAD(p, rest);

    status = get_param(&p, &rest, "", 0, &service);

    client->service = service;

    return IIIMF_STATUS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 289 of file role-data-client.c.

{
    int                     fd;
    IIIMF_status     status;
    char *           server_file;
    size_t           server_file_len;
    size_t           home_dir_len;
    struct stat             st;
    int                     stat_ret;
    char *           pa;
    const char *     p;
    size_t           rest;
    char *           node;
    char *           service;

    home_dir_len = strlen(client->home_dir);
    server_file_len = (home_dir_len + 1 + SERVER_COMPAT_FILE_LEN);

    server_file = (char *)malloc(server_file_len + 1);
    if (NULL == server_file) {
       return IIIMF_STATUS_MALLOC;
    }

    (void)strcpy(server_file, client->home_dir);
    *(server_file + home_dir_len) = '/';
    (void)strcpy(server_file + home_dir_len + 1, SERVER_COMPAT_FILE);

    fd = open(server_file, O_RDONLY, 0);
    free(server_file);
    if (fd < 0) return IIIMF_STATUS_CONFIG;
    stat_ret = fstat(fd, &st);
    if (stat_ret < 0) {
       return IIIMF_STATUS_CONFIG;
    }

    pa = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
    (void)close(fd);
    if (NULL == pa) return IIIMF_STATUS_CONFIG;

    p = pa;
    rest = st.st_size;

    while (0 < rest) {
       for (; 0 < rest; --rest, p++) {
           if (('\r' == *p) || ('\n' == *p)) {
              p += 1;
              rest -= 1;
              break;
           }
       }
       if (rest < SERVER_COMPAT_KEY_LEN) break;

       status = get_param_compat(&p, &rest,
                              SERVER_COMPAT_KEY,
                              SERVER_COMPAT_KEY_LEN,
                              &node);
       if (IIIMF_STATUS_SUCCESS == status) {
           client->server_node = node;
           p += 1;
           rest -= 1;
           break;
       }
    }
    if (NULL == client->server_node) {
       return IIIMF_STATUS_CONFIG;
    }

    status = get_param_compat(&p, &rest, "", 0, &service);

    (void)munmap(pa, st.st_size);

    if ('\0' == *service) {
       free(service);
       service = NULL;
    }

    if (IIIMF_STATUS_SUCCESS == status) {
       client->service = service;
    }

    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 215 of file role-data-client.c.

{
    int                     fd;
    IIIMF_status     status;
    char *           server_file;
    size_t           server_file_len;
    size_t           home_dir_len;
    struct stat             st;
    int                     stat_ret;
    char *           pa;
    const char *     p;
    size_t           rest;
    char *           node;
    char *           service;

    home_dir_len = strlen(client->home_dir);
    server_file_len = (home_dir_len + 1 + SERVER_FILE_LEN);

    server_file = (char *)malloc(server_file_len + 1);
    if (NULL == server_file) {
       return IIIMF_STATUS_MALLOC;
    }

    (void)strcpy(server_file, client->home_dir);
    *(server_file + home_dir_len) = '/';
    (void)strcpy(server_file + home_dir_len + 1, SERVER_FILE);

    fd = open(server_file, O_RDONLY, 0);
    free(server_file);
    if (fd < 0) return IIIMF_STATUS_CONFIG;

    stat_ret = fstat(fd, &st);
    if (stat_ret < 0) {
       return IIIMF_STATUS_CONFIG;
    }

    pa = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
    (void)close(fd);
    if (NULL == pa) return IIIMF_STATUS_CONFIG;

    p = pa;
    rest = st.st_size;

    POSITION_HEAD(p, rest);
    if (rest < NODE_KEY_LEN) {
       (void)munmap(pa, st.st_size);
       return IIIMF_STATUS_CONFIG;
    }

    status = get_param(&p, &rest, NODE_KEY, NODE_KEY_LEN, &node);
    if (IIIMF_STATUS_SUCCESS != status) {
       (void)munmap(pa, st.st_size);
       return status;
    }

    client->server_node = node;

    POSITION_HEAD(p, rest);
    if (rest < SERVICE_KEY_LEN) {
       (void)munmap(pa, st.st_size);
       return IIIMF_STATUS_SUCCESS;
    }

    status = get_param(&p, &rest, SERVICE_KEY, SERVICE_KEY_LEN, &service);

    (void)munmap(pa, st.st_size);

    client->service = service;

    return IIIMF_STATUS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char* iiimf_role_data_client_home_dir ( IIIMF_im *  im)

Definition at line 58 of file role-data-client.c.

{
    return im->role_data.client->home_dir;
}
IIIMF_status iiimf_role_data_client_new ( const char *  server_node,
const char *  service,
IIIMF_role_data_client **  client_ret 
)

Definition at line 440 of file role-data-client.c.

{
    IIIMF_role_data_client *       client;
    struct passwd *         pwd;
    IIIMF_status            status;
    struct utsname          name;

    status = IIIMF_STATUS_CONFIG;

    client = (IIIMF_role_data_client *)malloc(sizeof (IIIMF_role_data_client));
    if (NULL == client) return IIIMF_STATUS_MALLOC;

    client->user_name = NULL;
    client->home_dir = NULL;
    client->node = NULL;

    client->server_node = ((NULL == server_node) ? NULL : strdup(server_node));
    client->service = ((NULL == service) ? NULL : strdup(service));

    client->type = strdup(CLIENT_TYPE);

    client->os_name = NULL;
    client->os_arch = NULL;
    client->os_version = NULL;
    client->X_display_name = NULL;
    client->X_server_vendor = NULL;

    pwd = getpwuid(geteuid());
    if (NULL == pwd) {
       iiimf_role_data_client_delete(client);
       return IIIMF_STATUS_CONFIG;
    }

    client->user_name = strdup(pwd->pw_name);
    client->home_dir = strdup(pwd->pw_dir);

    endpwent();

    if ((NULL == client->user_name) ||
       (NULL == client->home_dir) ||
       ((NULL != server_node) && (NULL == client->server_node)) ||
       ((NULL != service) && (NULL == client->service))) {
       iiimf_role_data_client_delete(client);
       return IIIMF_STATUS_MALLOC;
    }

    if (-1 == uname(&name)) {
       iiimf_role_data_client_delete(client);
       return IIIMF_STATUS_CONFIG;
    }

    client->node = strdup(name.nodename);

    client->os_name = strdup(name.sysname);
    client->os_version = strdup(name.release);

#if defined(OS_ARCH)
    client->os_arch = strdup(OS_ARCH);
#else /* !OS_ARCH */
#if defined(HAVE_SYSINFO) && defined(SI_ARCHITECTURE)
    ret = sysinfo(SI_ARCHITECTURE, arch, sizeof (arch));
    if (-1 == ret) {
       client->os_arch = NULL;
    } else if ((0 == strcmp(arch, "sparc")) ||
              (0 == strcmp(arch, "ppc"))) {
       client->os_arch = strdup(arch);
    } else if (0 == strcmp(arch, "i386")) {
       client->os_arch = strdup("x86");
    } else {
       client->os_arch = strdup("Unknown");
    }
#else /* !HAVE_SYSINFO || !SI_ARCHITECTURE */
    client->os_arch = strdup("Unknown");
#endif /* !HAVE_SYSINFO || !SI_ARCHITECTURE */
#endif /* !OS_ARCH */

    if ((NULL == server_node) && (NULL == service)) {
       status = iiimf_role_data_client_environ_server(client);
       if (IIIMF_STATUS_SUCCESS != status) {
           status = iiimf_role_data_client_file_server(client);
       }
       if (IIIMF_STATUS_SUCCESS != status) {
           status = iiimf_role_data_client_file_compat_server(client);
       }
    }

    if (NULL == client->server_node) {
       client->server_node = strdup(NODE_DEFAULT);
    }
    if (NULL == client->service) {
       client->service = strdup(SERVICE_DEFAULT);
    }
    if ((NULL == client->node) || (NULL == client->service)) {
       iiimf_role_data_client_delete(client);
       return IIIMF_STATUS_MALLOC;
    }

    *client_ret = client;

    return IIIMF_STATUS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char* iiimf_role_data_client_node ( IIIMF_im *  im)

Definition at line 65 of file role-data-client.c.

{
    return im->role_data.client->node;
}
const char* iiimf_role_data_client_server_node ( IIIMF_im *  im)

Definition at line 72 of file role-data-client.c.

{
    return im->role_data.client->server_node;
}
const char* iiimf_role_data_client_service ( IIIMF_im *  im)

Definition at line 79 of file role-data-client.c.

{
    return im->role_data.client->service;
}
const char* iiimf_role_data_client_user_name ( IIIMF_im *  im)

Definition at line 51 of file role-data-client.c.

{
    return im->role_data.client->user_name;
}