自学教程：C++ thread_rwlock_unlock函数代码示例

static void worker_start (void){    worker_t *handler = calloc (1, sizeof(worker_t));    worker_control_create (&handler->wakeup_fd[0]);    handler->pending_clients_tail = &handler->pending_clients;    thread_spin_create (&handler->lock);    handler->last_p = &handler->clients;    thread_rwlock_wlock (&workers_lock);    if (worker_incoming == NULL)    {        worker_incoming = handler;        handler->thread = thread_create ("worker", worker, handler, THREAD_ATTACHED);        thread_rwlock_unlock (&workers_lock);        INFO0 ("starting incoming worker thread");        worker_start();  // single level recursion, just get a special worker thread set up        return;    }    handler->next = workers;    workers = handler;    worker_count++;    worker_least_used = worker_balance_to_check = workers;    thread_rwlock_unlock (&workers_lock);    handler->thread = thread_create ("worker", worker, handler, THREAD_ATTACHED);}

static int command_move_clients (client_t *client, source_t *source, int response){    const char *dest_source;    xmlDocPtr doc;    xmlNodePtr node;    int parameters_passed = 0;    char buf[255];    if((COMMAND_OPTIONAL(client, "destination", dest_source))) {        parameters_passed = 1;    }    if (!parameters_passed) {        doc = admin_build_sourcelist(source->mount, 0);        thread_rwlock_unlock (&source->lock);        return admin_send_response(doc, client, response, "moveclients.xsl");    }    INFO2 ("source is /"%s/", destination is /"%s/"", source->mount, dest_source);    doc = xmlNewDoc(XMLSTR("1.0"));    node = xmlNewDocNode(doc, NULL, XMLSTR("iceresponse"), NULL);    xmlDocSetRootElement(doc, node);    source_set_fallback (source, dest_source);    source->termination_count = source->listeners;    source->flags |= SOURCE_LISTENERS_SYNC;    snprintf (buf, sizeof(buf), "Clients moved from %s to %s",            source->mount, dest_source);    thread_rwlock_unlock (&source->lock);    xmlNewChild(node, NULL, XMLSTR("message"), XMLSTR(buf));    xmlNewChild(node, NULL, XMLSTR("return"), XMLSTR("1"));    return admin_send_response (doc, client, response, "response.xsl");}

int xslt_transform (xmlDocPtr doc, const char *xslfilename, client_t *client){    int     i, ret;    xsl_req *x;    thread_rwlock_rlock (&xslt_lock);    i = xslt_cached (xslfilename, NULL, client->worker->current_time.tv_sec);    i = xslt_req_sheet (client, doc, xslfilename, i);    x = client->shared_data;    switch (i)    {    case -1:        thread_rwlock_unlock (&xslt_lock);        xmlFreeDoc (doc);        client->shared_data = NULL;        ret = client_send_404 (client, "Could not parse XSLT file");        break;    case CACHESIZE:   // delayed        thread_rwlock_unlock (&xslt_lock);        return 0;    default:  // found it and ok to use        ret = xslt_send_sheet (client, doc, i);        break;    }    if (x)    {        free (x->cache.filename);        free (x->cache.disposition);        free (x);    }    return ret;}

static auth_result htpasswd_auth (auth_client *auth_user){    auth_t *auth = auth_user->client->auth;    htpasswd_auth_state *htpasswd = auth->state;    client_t *client = auth_user->client;    htpasswd_user entry;    void *result;    if (client->username == NULL || client->password == NULL)        return AUTH_FAILED;    htpasswd_recheckfile (htpasswd);    thread_rwlock_rlock (&htpasswd->file_rwlock);    entry.name = client->username;    if (avl_get_by_key (htpasswd->users, &entry, &result) == 0)    {        htpasswd_user *found = result;        char *hashed_pw;        thread_rwlock_unlock (&htpasswd->file_rwlock);        hashed_pw = get_hash (client->password, strlen (client->password));        if (strcmp (found->pass, hashed_pw) == 0)        {            free (hashed_pw);            return AUTH_OK;        }        free (hashed_pw);        DEBUG0 ("incorrect password for client");        return AUTH_FAILED;    }    DEBUG1 ("no such username: %s", client->username);    thread_rwlock_unlock (&htpasswd->file_rwlock);    return AUTH_FAILED;}

static void *yp_update_thread(void *arg){    if (!kitsune_is_updating()) { /**DSU control */        INFO0("YP update thread started");        yp_running = 1;    }    while (yp_running)    {      kitsune_update("yp_update"); /**DSU updatepoint */        struct yp_server *server;        thread_sleep (200000);        /* do the YP communication */        thread_rwlock_rlock (&yp_lock);        server = (struct yp_server *)active_yps;        while (server)        {            /* DEBUG1 ("trying %s", server->url); */            yp_process_server (server);            server = server->next;        }        thread_rwlock_unlock (&yp_lock);        /* update the local YP structure */        if (yp_update)        {            thread_rwlock_wlock (&yp_lock);            check_servers ();            server = (struct yp_server *)active_yps;            while (server)            {                /* DEBUG1 ("Checking yps %s", server->url); */                add_pending_yp (server);                delete_marked_yp (server);                server = server->next;            }            yp_update = 0;            thread_rwlock_unlock (&yp_lock);        }    }    thread_rwlock_destroy (&yp_lock);    thread_mutex_destroy (&yp_pending_lock);    /* free server and ypdata left */    while (active_yps)    {        struct yp_server *server = (struct yp_server *)active_yps;        active_yps = server->next;        destroy_yp_server (server);    }    return NULL;}

/* Not efficient; opens and scans the entire file for every request */static auth_result htpasswd_auth(auth_t *auth, source_t *source, char *username, char *password){    htpasswd_auth_state *state = auth->state;    FILE *passwdfile = NULL;    char line[MAX_LINE_LEN];    char *sep;    thread_rwlock_rlock(&state->file_rwlock);    if (!state->allow_duplicate_users) {        if (auth_is_listener_connected(source, username)) {            thread_rwlock_unlock(&state->file_rwlock);            return AUTH_FORBIDDEN;        }    }    passwdfile = fopen(state->filename, "rb");    if(passwdfile == NULL) {        WARN2("Failed to open authentication database /"%s/": %s",                 state->filename, strerror(errno));        thread_rwlock_unlock(&state->file_rwlock);        return AUTH_FAILED;    }    while(get_line(passwdfile, line, MAX_LINE_LEN)) {        if(!line[0] || line[0] == '#')            continue;        sep = strchr(line, ':');        if(sep == NULL) {            DEBUG0("No seperator in line");            continue;        }        *sep = 0;        if(!strcmp(username, line)) {            /* Found our user, now: does the hash of password match hash? */            char *hash = sep+1;            char *hashed_password = get_hash(password, strlen(password));            if(!strcmp(hash, hashed_password)) {                fclose(passwdfile);                free(hashed_password);                thread_rwlock_unlock(&state->file_rwlock);                return AUTH_OK;            }            free(hashed_password);            /* We don't keep searching through the file */            break;         }    }    fclose(passwdfile);    thread_rwlock_unlock(&state->file_rwlock);    return AUTH_FAILED;}

/* Mark an existing entry in the YP list as to be marked for deletion */void yp_remove (const char *mount){    struct yp_server *server = (struct yp_server *)active_yps;    thread_rwlock_rlock (&yp_lock);    while (server)    {        ypdata_t *list = server->mounts;        while (1)        {            ypdata_t *yp = find_yp_mount (list, mount);            if (yp == NULL)                break;            if (yp->release || yp->remove)            {                list = yp->next;                continue;   /* search again these are old entries */            }            DEBUG2 ("release %s on YP %s", mount, server->url);            yp->release = 1;            yp->next_update = 0;            yp_update = 1;        }        server = server->next;    }    thread_rwlock_unlock (&yp_lock);}

static int directory_recheck (client_t *client){    int ret = -1;    thread_rwlock_rlock (&yp_lock);    do {        if (ypclient.connection.error)            break;        if (active_yps || yp_update)        {            ret = 0;            if (yp_update || active_yps->mounts)            {                if (yp_update || client->counter <= client->worker->current_time.tv_sec)                {                    client->counter = (uint64_t)-1;                    client->flags &= ~CLIENT_ACTIVE;                    thread_create ("YP Thread", yp_update_thread, NULL, THREAD_DETACHED);                    break;                }            }        }        client->schedule_ms = client->worker->time_ms + 1000;    } while (0);    thread_rwlock_unlock (&yp_lock);    return ret;}

static void worker_stop (void){    worker_t *handler;    if (workers == NULL)        return;    thread_rwlock_wlock (&workers_lock);    handler = workers;    workers = handler->next;    worker_least_used = worker_balance_to_check = workers;    if (workers)        workers->move_allocations = 100;    worker_count--;    thread_rwlock_unlock (&workers_lock);    handler->running = 0;    worker_wakeup (handler);    thread_join (handler->thread);    thread_spin_destroy (&handler->lock);    sock_close (handler->wakeup_fd[1]);    sock_close (handler->wakeup_fd[0]);    free (handler);}

void connection_accept_loop(void){    connection_t *con;    _build_pool();    while (global.running == ICE_RUNNING)    {        if (global . schedule_config_reread)        {            /* reread config file */            INFO0("Scheduling config reread ...");            connection_inject_event(EVENT_CONFIG_READ, NULL);            global . schedule_config_reread = 0;        }        con = _accept_connection();        if (con) {            _add_connection(con);        }    }    /* Give all the other threads notification to shut down */    thread_cond_broadcast(&global.shutdown_cond);    _destroy_pool();    /* wait for all the sources to shutdown */    thread_rwlock_wlock(&_source_shutdown_rwlock);    thread_rwlock_unlock(&_source_shutdown_rwlock);}

/* Add YP entries to active servers */void yp_add (const char *mount){    struct yp_server *server;    /* make sure YP thread is not modifying the lists */    thread_rwlock_rlock (&yp_lock);    /* make sure we don't race against another yp_add */    thread_mutex_lock (&yp_pending_lock);    server = (struct yp_server *)active_yps;    while (server)    {        ypdata_t *yp;        /* add new ypdata to each servers pending yp */        if ((yp = create_yp_entry (mount)) != NULL)        {            DEBUG2 ("Adding %s to %s", mount, server->url);            yp->server = server;            yp->touch_interval = server->touch_interval;            yp->next = server->pending_mounts;            yp->next_update = time(NULL) + 5;            server->pending_mounts = yp;            yp_update = 1;        }        server = server->next;    }    thread_mutex_unlock (&yp_pending_lock);    thread_rwlock_unlock (&yp_lock);}

/* This is similar to yp_remove, but we force a touch * attempt */void yp_touch (const char *mount){    struct yp_server *server = (struct yp_server *)active_yps;    ypdata_t *search_list = NULL;    thread_rwlock_rlock (&yp_lock);    if (server)        search_list = server->mounts;    while (server)    {        ypdata_t *yp = find_yp_mount (search_list, mount);        if (yp)        {            /* we may of found old entries not purged yet, so skip them */            if (yp->release != 0 || yp->remove != 0)            {                search_list = yp->next;                continue;            }            /* don't update the directory if there is a touch scheduled soon */            if (yp->process == do_yp_touch && now + yp->touch_interval - yp->next_update > 60)                yp_schedule (yp, 0);        }        server = server->next;        if (server)            search_list = server->mounts;    }    thread_rwlock_unlock (&yp_lock);}

static int command_fallback (client_t *client, source_t *source, int response){    char *mount = strdup (source->mount);    mount_proxy *mountinfo;    ice_config_t *config;    thread_rwlock_unlock (&source->lock);    DEBUG0("Got fallback request");    config = config_grab_config();    mountinfo = config_find_mount (config, mount);    free (mount);    if (mountinfo)    {        const char *fallback;        char buffer[200];        if (COMMAND_REQUIRE(client, "fallback", fallback) < 0)            return client_send_400 (client, "missing arg, fallback");        xmlFree (mountinfo->fallback_mount);        mountinfo->fallback_mount = (char *)xmlCharStrdup (fallback);        snprintf (buffer, sizeof (buffer), "Fallback for /"%s/" configured", mountinfo->mountname);        config_release_config ();        return html_success (client, buffer);    }    config_release_config ();    return client_send_400 (client, "no mount details available");}

/* This is similar to yp_remove, but we force a touch * attempt */void yp_touch (const char *mount){    struct yp_server *server = (struct yp_server *)active_yps;    time_t trigger;    ypdata_t *search_list = NULL;    thread_rwlock_rlock (&yp_lock);    /* do update in 3 secs, give stats chance to update */    trigger = time(NULL) + 3;    if (server)        search_list = server->mounts;    while (server)    {        ypdata_t *yp = find_yp_mount (search_list, mount);        if (yp)        {            /* we may of found old entries not purged yet, so skip them */            if (yp->release != 0 || yp->remove != 0)            {                search_list = yp->next;                continue;            }            /* only force if touch */            if (yp->process == do_yp_touch)                yp->next_update = trigger;        }        server = server->next;        if (server)            search_list = server->mounts;    }    thread_rwlock_unlock (&yp_lock);}

static int command_show_listeners (client_t *client, source_t *source, int response){    xmlDocPtr doc;    xmlNodePtr node, srcnode;    uint64_t id = -1;    const char *ID_str = NULL;    char buf[22];    doc = xmlNewDoc(XMLSTR("1.0"));    node = xmlNewDocNode(doc, NULL, XMLSTR("icestats"), NULL);    srcnode = xmlNewChild(node, NULL, XMLSTR("source"), NULL);    xmlSetProp(srcnode, XMLSTR("mount"), XMLSTR(source->mount));    xmlDocSetRootElement(doc, node);    snprintf(buf, sizeof(buf), "%lu", source->listeners);    xmlNewChild(srcnode, NULL, XMLSTR("listeners"), XMLSTR(buf));    COMMAND_OPTIONAL(client, "id", ID_str);    if (ID_str)        sscanf (ID_str, "%" SCNu64, &id);    if (id == -1)        admin_source_listeners (source, srcnode);    else    {        client_t *listener = source_find_client (source, id);        if (listener)            stats_listener_to_xml (listener, srcnode);    }    thread_rwlock_unlock (&source->lock);    return admin_send_response (doc, client, response, "listclients.xsl");}

void yp_recheck_config (ice_config_t *config){    int i;    struct yp_server *server;    DEBUG0("Updating YP configuration");    thread_rwlock_rlock (&yp_lock);    server = (struct yp_server *)active_yps;    while (server)    {        server->remove = 1;        server = server->next;    }    /* for each yp url in config, check to see if one exists        if not, then add it. */    for (i=0 ; i < config->num_yp_directories; i++)    {        server = find_yp_server (config->yp_url[i]);        if (server == NULL)        {            server = calloc (1, sizeof (struct yp_server));            if (server == NULL)            {                destroy_yp_server (server);                break;            }            server->url = strdup (config->yp_url[i]);            server->url_timeout = config->yp_url_timeout[i];            server->touch_interval = config->yp_touch_interval[i];            server->curl = curl_easy_init();            if (server->curl == NULL)            {                destroy_yp_server (server);                break;            }            if (server->touch_interval < 30)                server->touch_interval = 30;            curl_easy_setopt (server->curl, CURLOPT_URL, server->url);            curl_easy_setopt (server->curl, CURLOPT_HEADERFUNCTION, handle_returned_header);            curl_easy_setopt (server->curl, CURLOPT_WRITEFUNCTION, handle_returned_data);            curl_easy_setopt (server->curl, CURLOPT_WRITEDATA, server->curl);            curl_easy_setopt (server->curl, CURLOPT_TIMEOUT, server->url_timeout);            curl_easy_setopt (server->curl, CURLOPT_NOSIGNAL, 1L);            curl_easy_setopt (server->curl, CURLOPT_ERRORBUFFER, &(server->curl_error[0]));            server->next = (struct yp_server *)pending_yps;            pending_yps = server;            INFO3 ("Adding new YP server /"%s/" (timeout %ds, default interval %ds)",                    server->url, server->url_timeout, server->touch_interval);        }        else        {            server->remove = 0;        }    }    thread_rwlock_unlock (&yp_lock);    yp_update = 1;}

static void *yp_update_thread(void *arg){    struct yp_server *server;    yp_thread = thread_self();    /* DEBUG0("YP thread started"); */    /* do the YP communication */    thread_rwlock_rlock (&yp_lock);    ypclient.counter = -1;    server = (struct yp_server *)active_yps;    while (server)    {        /* DEBUG1 ("trying %s", server->url); */        yp_process_server (server);        server = server->next;    }    thread_rwlock_unlock (&yp_lock);    /* update the local YP structure */    if (yp_update)    {        thread_rwlock_wlock (&yp_lock);        check_servers ();        server = (struct yp_server *)active_yps;        while (server)        {            /* DEBUG1 ("Checking yps %s", server->url); */            add_pending_yp (server);            delete_marked_yp (server);            server = server->next;        }        yp_update = 0;        thread_rwlock_unlock (&yp_lock);    }    yp_thread = NULL;    /* DEBUG0("YP thread shutdown"); */    ypclient.flags |= CLIENT_ACTIVE;    worker_wakeup (ypclient.worker);    return NULL;}

void auth_shutdown (void){    if (allow_auth == 0)        return;    allow_auth = 0;    thread_rwlock_wlock (&auth_lock);    thread_rwlock_unlock (&auth_lock);    thread_rwlock_destroy (&auth_lock);    INFO0 ("Auth shutdown complete");}

int main(void){	int rv;	thread_rwlock_t *thread_rwlock = NULL;	rv = thread_rwlock_create(&thread_rwlock);	rv = thread_rwlock_wrlock(thread_rwlock);	rv = thread_rwlock_unlock(thread_rwlock);	thread_rwlock_destroy(thread_rwlock);	return 0;}

static int command_kill_client (client_t *client, source_t *source, int response){    const char *idtext;    uint64_t id;    client_t *listener;    xmlDocPtr doc;    xmlNodePtr node;    char buf[50] = "";    if (COMMAND_REQUIRE(client, "id", idtext) < 0)    {        thread_rwlock_unlock (&source->lock);        return client_send_400 (client, "missing arg, id");    }    sscanf (idtext, "%" SCNu64, &id);    listener = source_find_client(source, id);    doc = xmlNewDoc(XMLSTR("1.0"));    node = xmlNewDocNode(doc, NULL, XMLSTR("iceresponse"), NULL);    xmlDocSetRootElement(doc, node);    if(listener != NULL) {        INFO1("Admin request: client %d removed", id);        /* This tags it for removal on the next iteration of the main source         * loop         */        listener->connection.error = 1;        snprintf(buf, sizeof(buf), "Client %" PRIu64 " removed", id);        xmlNewChild(node, NULL, XMLSTR("message"), XMLSTR(buf));        xmlNewChild(node, NULL, XMLSTR("return"), XMLSTR("1"));    }    else {        snprintf(buf, sizeof(buf), "Client %" PRIu64 " not found", id);        xmlNewChild(node, NULL, XMLSTR("message"), XMLSTR(buf));        xmlNewChild(node, NULL, XMLSTR("return"), XMLSTR("0"));    }    thread_rwlock_unlock (&source->lock);    return admin_send_response (doc, client, response, "response.xsl");}

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock){    if (rwlock == NULL)        return_errno(EINVAL, EINVAL);    if (*rwlock == PTHREAD_RWLOCK_INITIALIZER)        if (pthread_rwlock_init(rwlock, NULL) != OK)            return errno;    if (!thread_rwlock_unlock((rwlock_t *)(*rwlock)))        return errno;    return OK;}

/* Check for changes in the YP servers configured */static void check_servers (void){    struct yp_server *server = (struct yp_server *)active_yps,                     **server_p = (struct yp_server **)&active_yps;    while (server)    {        if (server->remove)        {            struct yp_server *to_go = server;            DEBUG1 ("YP server /"%s/"removed", server->url);            *server_p = server->next;            server = server->next;            destroy_yp_server (to_go);            continue;        }        server_p = &server->next;        server = server->next;    }    /* add new server entries */    while (pending_yps)    {        avl_node *node;        server = (struct yp_server *)pending_yps;        pending_yps = server->next;        DEBUG1("Add pending yps %s", server->url);        server->next = (struct yp_server *)active_yps;        active_yps = server;        /* new YP server configured, need to populate with existing sources */        avl_tree_rlock (global.source_tree);        node = avl_get_first (global.source_tree);        while (node)        {            ypdata_t *yp;            source_t *source = node->key;            thread_rwlock_rlock (&source->lock);            if (source->yp_public && (yp = create_yp_entry (source->mount)) != NULL)            {                DEBUG1 ("Adding existing mount %s", source->mount);                yp->server = server;                yp->touch_interval = server->touch_interval;                yp->next = server->mounts;                server->mounts = yp;            }            thread_rwlock_unlock (&source->lock);            node = avl_get_next (node);        }        avl_tree_unlock (global.source_tree);    }}

static int command_show_image (client_t *client, const char *mount){    source_t *source;    avl_tree_rlock (global.source_tree);    source = source_find_mount_raw (mount);    if (source && source->format && source->format->get_image)    {        thread_rwlock_rlock (&source->lock);        avl_tree_unlock (global.source_tree);        if (source->format->get_image (client, source->format) == 0)        {            thread_rwlock_unlock (&source->lock);            return fserve_setup_client (client);        }        thread_rwlock_unlock (&source->lock);    }    else        avl_tree_unlock (global.source_tree);    return client_send_404 (client, "No image available");}

static int command_shoutcast_metadata (client_t *client, source_t *source){    const char *action;    const char *value;    int same_ip = 1;    if (COMMAND_REQUIRE(client, "mode", action) < 0)    {        thread_rwlock_unlock (&source->lock);        return client_send_400 (client, "missing arg, mode");    }    if ((source->flags & SOURCE_SHOUTCAST_COMPAT) == 0)    {        thread_rwlock_unlock (&source->lock);        ERROR0 ("illegal request on non-shoutcast compatible stream");        return client_send_400 (client, "Not a shoutcast compatible stream");    }    if (strcmp (action, "updinfo") == 0)    {        DEBUG0("Got shoutcast metadata update request");        if (COMMAND_REQUIRE (client, "song", value) < 0)        {            thread_rwlock_unlock (&source->lock);            return client_send_400 (client, "missing arg, song");        }        if (source->client && strcmp (client->connection.ip, source->client->connection.ip) != 0)            if (connection_check_admin_pass (client->parser) == 0)                same_ip = 0;        if (same_ip && source->format && source->format->set_tag)        {            httpp_set_query_param (client->parser, "mount", client->server_conn->shoutcast_mount);            source->format->set_tag (source->format, "title", value, NULL);            source->format->set_tag (source->format, NULL, NULL, NULL);            DEBUG2("Metadata on mountpoint %s changed to /"%s/"", source->mount, value);            thread_rwlock_unlock (&source->lock);            return html_success(client, "Metadata update successful");        }        thread_rwlock_unlock (&source->lock);        return client_send_400 (client, "mountpoint will not accept URL updates");    }    if (strcmp (action, "viewxml") == 0)    {        xmlDocPtr doc;        DEBUG0("Got shoutcast viewxml request");        thread_rwlock_unlock (&source->lock);        doc = stats_get_xml (STATS_ALL, source->mount);        return admin_send_response (doc, client, XSLT, "viewxml.xsl");    }    thread_rwlock_unlock (&source->lock);    return client_send_400 (client, "No such action");}

static auth_result htpasswd_adduser (auth_t *auth, const char *username, const char *password){    FILE *passwdfile;    char *hashed_password = NULL;    htpasswd_auth_state *state = auth->state;    htpasswd_user entry;    void *result;    htpasswd_recheckfile (state);    thread_rwlock_wlock (&state->file_rwlock);    entry.name = (char*)username;    if (avl_get_by_key (state->users, &entry, &result) == 0)    {        thread_rwlock_unlock (&state->file_rwlock);        return AUTH_USEREXISTS;    }    passwdfile = fopen(state->filename, "ab");    if (passwdfile == NULL)    {        thread_rwlock_unlock (&state->file_rwlock);        WARN2("Failed to open authentication database /"%s/": %s",                 state->filename, strerror(errno));        return AUTH_FAILED;    }    hashed_password = get_hash(password, strlen(password));    if (hashed_password) {        fprintf(passwdfile, "%s:%s/n", username, hashed_password);        free(hashed_password);    }    fclose(passwdfile);    thread_rwlock_unlock (&state->file_rwlock);    return AUTH_USERADDED;}

void client_add_incoming (client_t *client){    worker_t *handler;    thread_rwlock_rlock (&workers_lock);    handler = worker_incoming;    thread_spin_lock (&handler->lock);    thread_rwlock_unlock (&workers_lock);    worker_add_client (handler, client);    thread_spin_unlock (&handler->lock);    worker_wakeup (handler);}

void client_add_worker (client_t *client){    worker_t *handler;    thread_rwlock_rlock (&workers_lock);    /* add client to the handler with the least number of clients */    handler = worker_selected();    thread_spin_lock (&handler->lock);    thread_rwlock_unlock (&workers_lock);    worker_add_client (handler, client);    thread_spin_unlock (&handler->lock);    worker_wakeup (handler);}

static int command_updatemetadata(client_t *client, source_t *source, int response){    xmlDocPtr doc;    xmlNodePtr node, srcnode;    thread_rwlock_unlock (&source->lock);    doc = xmlNewDoc(XMLSTR("1.0"));    node = xmlNewDocNode(doc, NULL, XMLSTR("icestats"), NULL);    srcnode = xmlNewChild(node, NULL, XMLSTR("source"), NULL);    xmlSetProp(srcnode, XMLSTR("mount"), XMLSTR(source->mount));    xmlDocSetRootElement(doc, node);    return admin_send_response (doc, client, response, "updatemetadata.xsl");}

int auth_get_userlist(source_t *source, xmlNodePtr srcnode){    int ret = 0;    htpasswd_auth_state *state;    if (source->authenticator) {        if (!strcmp(source->authenticator->type, "htpasswd")) {            state = source->authenticator->state;            thread_rwlock_rlock(&state->file_rwlock);            ret = auth_get_htpasswd_userlist(source->authenticator, srcnode);            thread_rwlock_unlock(&state->file_rwlock);        }    }    return ret;}

int auth_deleteuser(source_t *source, char *username){    htpasswd_auth_state *state;    int ret = 0;    if (source->authenticator) {        if (!strcmp(source->authenticator->type, "htpasswd")) {            state = source->authenticator->state;            thread_rwlock_wlock(&state->file_rwlock);            ret = auth_htpasswd_deleteuser(source->authenticator, username);            thread_rwlock_unlock(&state->file_rwlock);        }    }    return ret;}