auth.c

Go to the documentation of this file.

#include "config.h"
#include <pwd.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include "list.h"
#include "common.h"
#include "auth-libsecret.h"
#include "auth.h"
 
struct authitem{
    char            *name;      // item name
    time_t          touch_time; // item touch time
    struct authinfo     *info;
    struct{
    int         child_cnt;  // number of subitem
    int         max_child_cnt;  // maximum number of subitem
    struct authitem     **childs;   // sorted list of subitems
    };
};
 
static char     auth_login[64]      = "guest";
static char     *auth_fake_password = "********";
static struct authinfo  authinfo_default    = {{NULL, NULL}, 1, "", auth_login, ""};
static LIST     authinfo_list       = STATIC_LIST_INITIALIZER(authinfo_list);
static struct authitem  authroot        = {NULL, (time_t) 0, NULL, {0, 0, NULL}};
static pthread_mutex_t  m_auth          = PTHREAD_MUTEX_INITIALIZER;
 
 
void auth_set_default_login_name(const char *name){
    strncpy(auth_login, name, sizeof(auth_login));
    auth_login[sizeof(auth_login) - 1] = '\0';
    DPRINTF(5, "login=%s\n", auth_login);
}
 
static struct authinfo * authinfo_create_new(
                const char *domain,
                const char *user,
                const char *password){
 
    size_t      len;
    struct authinfo *info;
 
    len = sizeof(struct authinfo) +
        strlen(domain) + strlen(user) + strlen(password) + 3;
    if ((info = malloc(len)) == NULL) return NULL;
    memset(info, 0, len);
 
    info->domain   = (char *) (info + 1);
    info->user     = info->domain + strlen(domain) + 1;
    info->password = info->user + strlen(user) + 1;
 
    strcpy(info->domain,   domain);
    strcpy(info->user,     user);
    strcpy(info->password, password);
 
    return info;
}
 
static inline void authinfo_delete(struct authinfo *info){
    free(info);
}
 
static inline int authinfo_compare(struct authinfo *info,
                const char *domain,
                const char *user,
                const char *password){
    return ((strcmp(info->domain,   domain)   == 0) &&
        (strcmp(info->user,     user)     == 0) &&
        (strcmp(info->password, password) == 0));
}
 
static struct authinfo * authinfo_find_in_list(
                const char *domain,
                const char *user,
                const char *password){
 
    struct authinfo *info;
    LIST        *elem;
 
    elem = first_list_elem(&authinfo_list);
    while(is_valid_list_elem(&authinfo_list, elem)){
    info = list_entry(elem, struct authinfo, entries);
    if (authinfo_compare(info, domain, user, password)) return info;
    elem = elem->next;
    }
    return NULL;
}
 
static struct authinfo * authinfo_store_list(
                const char *domain,
                const char *user,
                const char *password){
 
    struct authinfo *info;
 
    DPRINTF(10, "domain=%s, user=%s, password=%s\n",
            domain, user, auth_fake_password);
 
    info = authinfo_find_in_list(domain, user, password);
    if (info != NULL){
    remove_from_list(&authinfo_list, &info->entries);
    }else{
    info = authinfo_create_new(domain, user, password);
    if (info == NULL) return NULL;
    }
 
    info->ref_count++;
    add_to_list_back(&authinfo_list, &info->entries);
    return info;
}
 
static void authinfo_release(struct authinfo *info){
    info->ref_count--;
    if (info->ref_count == 0){
    remove_from_list(&authinfo_list, &info->entries);
    authinfo_delete(info);
    }
}
 
static struct authitem* authitem_create_item(const char *name){
    struct authitem *item;
 
    item = malloc(sizeof(struct authitem) + strlen(name) + 1);
    if (item == NULL) return NULL;
 
    memset(item, 0 , sizeof(struct authitem));
    item->name = (char *) (item + 1);
    strcpy(item->name, name);
    item->touch_time = time(NULL);
    return item;
}
 
static inline void authitem_delete_item(struct authitem *item){
    if (item->info != NULL) authinfo_release(item->info);
    if (item->childs != NULL) free(item->childs);
    free(item);
}
 
static void authitem_delete_obsolete_items(struct authitem *item, time_t threshold){
    int     i;
 
    for(i = item->child_cnt - 1; i >= 0; i--){
    authitem_delete_obsolete_items(item->childs[i], threshold);
    if ((item->childs[i]->info == NULL) && 
        (item->childs[i]->childs == NULL)){
 
        authitem_delete_item(item->childs[i]);
        if (i != item->child_cnt - 1){
        memmove(&item->childs[i],
            &item->childs[i + 1],
            (item->child_cnt - i - 1) * sizeof(struct authitem *));
        }
        item->child_cnt--;
    }
    }
    if ((item->touch_time < threshold) && (item->info != NULL)){
    authinfo_release(item->info);
    item->info = NULL;
    }
    if ((item->child_cnt == 0) && (item->childs != NULL)){
    free(item->childs);
    item->childs = NULL;
    item->max_child_cnt = 0;
    }
}
 
/*
 * This function search for an item in specified authitem subitems,
 * subitems MUST be sorted alphabetically, so we can bisect.
 *
 * return:
 *   a) item position, if item with specified name was found
 *   b) negative value -(pos+1), if item was not found,
 *      where 'pos' is the position to insert the new element
 */
static int authitem_find_subitem(struct authitem *item, const char *name){
    int     first = 0, last = item->child_cnt - 1;
 
    while(first <= last){
    int i       = (first + last) >> 1;
    int result  = strcasecmp(item->childs[i]->name, name);
 
    if (result == 0) return i;
    if (result < 0) first = i + 1;
    else last = i - 1;
    }
    return -(first + 1);
}
 
/*
 * This function insert an element to specified authitem,
 * insert position MUST be obtained with authitem_find_subitem().
 *
 * return:
 *   a) zero, if no errors
 *   b) (-1), if insertion failed
 */
static int authitem_insert_subitem(struct authitem *item,
                struct authitem *subitem, int pos){
    if ((pos > item->child_cnt) || (pos < 0)) return -1;
 
    if (item->max_child_cnt == item->child_cnt){
    struct authitem **new_childs;
    int     new_max_cnt;
 
    new_max_cnt = (item->max_child_cnt == 0) ?
            64 : 2 * item->max_child_cnt;
    new_childs = realloc(item->childs,
            new_max_cnt * sizeof(struct authitem *));
    if (new_childs == NULL) return -1;
 
    item->max_child_cnt = new_max_cnt;
    item->childs = new_childs;
    }
 
    if (pos < item->child_cnt){
    memmove(&item->childs[pos + 1],
        &item->childs[pos],
        (item->child_cnt - pos) * sizeof(struct authitem *));
    }
    item->childs[pos] = subitem;
    item->child_cnt++;
    return 0;
}
 
static struct authitem * authitem_get_subitem(
                struct authitem *item,
                const char *name){
    int         pos;
    struct authitem *subitem;
 
    pos = authitem_find_subitem(item, name);
    if (pos < 0){
    /* create new subitem and add it to item */
    subitem = authitem_create_item(name);
    if (subitem == NULL) return NULL;
    pos = -(pos + 1);
    if (authitem_insert_subitem(item, subitem, pos) != 0){
        authitem_delete_item(subitem);
        return NULL;
    }
    }
    return item->childs[pos];
}
 
struct authinfo * auth_get_authinfo(
                const char *domain,
                const char *server,
                const char *share,
                int *suitability){
 
    int         pos;
    struct authitem *item;
    struct authinfo *info;
 
    DPRINTF(10, "domain=%s, server=%s, share=%s\n", domain, server, share);
 
    if ((server == NULL) || (*server == '\0')) return NULL;
    if (domain == NULL) domain = "";
    if (share  == NULL) share  = "";
 
    item = &authroot;
    info = &authinfo_default;
    *suitability = AUTH_FALLBACK;
    pthread_mutex_lock(&m_auth);
    if (item->info != NULL){
        info = item->info;
        *suitability = AUTH_MATCH_DEFAULT;
    }
    if (*domain != '\0'){
        pos = authitem_find_subitem(item, domain);
        if ((pos >= 0) && (item->childs[pos]->info != NULL)){
        info = item->childs[pos]->info;
        *suitability = AUTH_MATCH_DOMAIN_COMPAT;
        }
    }
 
    if ((pos = authitem_find_subitem(item, server)) < 0) goto end;
    item = item->childs[pos];
    if (item->info != NULL){
        info = item->info;
        *suitability = AUTH_MATCH_SERVER;
    }
 
    if (*share == '\0') goto end;
    if ((pos = authitem_find_subitem(item, share)) < 0) goto end;
    item = item->childs[pos];
    if (item->info != NULL){
        info = item->info;
        *suitability = AUTH_MATCH_RESOURCE;
    }
 
      end:
        info->ref_count++;
    pthread_mutex_unlock(&m_auth);
    DPRINTF(10, "domain=%s, user=%s, password=%s, suitability=%d\n",
        info->domain, info->user, auth_fake_password, *suitability);
    return info;
}
 
void auth_release_authinfo(struct authinfo *info){
    pthread_mutex_lock(&m_auth);
    authinfo_release(info);
    pthread_mutex_unlock(&m_auth);
}
 
int auth_store_auth_data(const char *server,
                const char *share,
                const char *domain,
                const char *user,
                const char *password){
 
    int         result;
    struct authinfo *info;
    struct authitem *item;
 
    DPRINTF(10, "smb://%s/%s, domain=%s, user=%s, password=%s\n",
            server, share, domain, user, auth_fake_password);
 
    if ((user == NULL) || (*user == '\0')) return -1;
    if (server   == NULL) server   = "";
    if (share    == NULL) share    = "";
    if (domain   == NULL) domain   = "";
    if (password == NULL) password = "";
    if ((*server == '\0') && (*share != '\0')) return -1;
 
    result = -1;
    item = &authroot;
    pthread_mutex_lock(&m_auth);
    if (*server == '\0') goto update_info;
    if ((item = authitem_get_subitem(item, server)) == NULL) goto error;
 
    if (*share == '\0') goto update_info;
    if ((item = authitem_get_subitem(item, share)) == NULL) goto error;
 
      update_info:
    if ((item->info == NULL) ||
        ! authinfo_compare(item->info, domain, user, password)){
 
        info = authinfo_store_list(domain, user, password);
        if (info == NULL) goto error;
        if (item->info != NULL) authinfo_release(item->info);
        item->info = info;
    }
    item->touch_time = time(NULL);
    result = 0;
 
      error:
    pthread_mutex_unlock(&m_auth);
    return result;
}
 
void auth_delete_obsolete(time_t threshold){
    pthread_mutex_lock(&m_auth);
    authitem_delete_obsolete_items(&authroot, threshold);
    pthread_mutex_unlock(&m_auth);
}