[gssapi-openssh.git] / openssh / ssh-globus-usage.c

/*
 * Copyright 2009 The Board of Trustees of the University
 * of Illinois.  See the LICENSE file for detailed license information.
 *
 * Portions, specifically log_usage_stats(), ssh_usage_stats_init(),
 * ssh_usage_stats_close(), ssh_usage_ent_s, ssh_usage_tag_e and
 * TAG #defines were based on those from Usage Metrics portions of:
 * gridftp/server/source/globus_i_gfs_log.c
 *
 * Copyright 1999-2006 University of Chicago
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <stdarg.h>

#include "log.h"
#include "ssh-globus-usage.h"

#ifdef HAVE_GLOBUS_USAGE

static globus_list_t *usage_handle_list = NULL;

#define SSH_GLOBUS_USAGE_ID 12
#define SSH_GLOBUS_USAGE_VER 0

#define SSH_GLOBUS_DEFAULT_TAGLIST "VvMm"
#define SSH_GLOBUS_ALL_TAGLIST     "VvMmIuU"
#define SSH_GLOBUS_TAGCOUNT 25

typedef enum ssh_usage_tag_e
{
    SSH_GLOBUS_USAGE_SSH_VER        = 'V',
    SSH_GLOBUS_USAGE_SSL_VER        = 'v',
    SSH_GLOBUS_USAGE_METHOD         = 'M',
    SSH_GLOBUS_USAGE_MECHANISM      = 'm',
    SSH_GLOBUS_USAGE_CLIENTIP       = 'I',
    SSH_GLOBUS_USAGE_USERNAME       = 'u',
    SSH_GLOBUS_USAGE_USERDN         = 'U'
    /* !! ADD to ALL_TAGLIST above and to globus_usage_stats_send()
          invocation below when adding here */
} ssh_usage_tag_t;

typedef struct ssh_usage_ent_s
{
    globus_usage_stats_handle_t         handle;
    char *                              target;
    char *                              taglist;
} ssh_usage_ent_t;


globus_result_t
ssh_usage_stats_init(int disable_usage_stats, char *usage_stats_targets)
{
    globus_result_t                     result;
    char *                              target_str = NULL;
    char *                              ptr = ptr;
    char *                              target = NULL;
    char *                              entry = NULL;
    globus_list_t *                     list = NULL;
    ssh_usage_ent_t *               usage_ent = NULL;

    if (disable_usage_stats)
	return GLOBUS_SUCCESS;

    result = globus_module_activate(GLOBUS_USAGE_MODULE);
    if (result != GLOBUS_SUCCESS)
    {
        error("ERROR: couldn't activate USAGE module");
        return result;
    }

    if (!usage_stats_targets ||
        !strcasecmp(usage_stats_targets, "default"))
        target_str = strdup(CILOGON_COLLECTOR);
    else
        target_str = strdup(usage_stats_targets);

    if (target_str == NULL)
    {
        error("ERROR: strdup failure for target_str");
        goto error;
    }
    debug("Processing usage_stats_target (%s)\n", target_str);

    if(target_str && strchr(target_str, '!'))
    {
        target = target_str;

        do {
            usage_ent = (ssh_usage_ent_t *) malloc(sizeof(ssh_usage_ent_t));
            if (usage_ent == NULL)
            {
                error("ERROR: couldn't allocate for ssh_usage_ent_t");
                goto error;
            }

            if ((ptr = strchr(target, ',')) != NULL)
                *ptr = '\0';

            entry = strdup(target);
            if (entry == NULL)
            {
                error("ERROR: strdup failure for target");
                goto error;
            }

            if (ptr)
                target = ptr + 1;
            else
                target = NULL;

            if((ptr = strchr(entry, '!')) != NULL)
            {
                *ptr = '\0';
                usage_ent->taglist = strdup(ptr + 1);
                if (usage_ent->taglist == NULL)
                {
                    error("ERROR: strdup failure for taglist");
                    goto error;
                }
                if(strlen(usage_ent->taglist) > SSH_GLOBUS_TAGCOUNT)
                {
                    usage_ent->taglist[SSH_GLOBUS_TAGCOUNT + 1] = '\0';
                }
            }
            else
            {
                usage_ent->taglist = strdup(SSH_GLOBUS_DEFAULT_TAGLIST);
                if (usage_ent->taglist == NULL)
                {
                    error("ERROR: couldn't allocate for taglist");
                    goto error;
                }
            }
            
            if(strcasecmp(usage_ent->taglist, "default") == 0)
            {
                free(usage_ent->taglist);
                usage_ent->taglist = strdup(SSH_GLOBUS_DEFAULT_TAGLIST);
                if (usage_ent->taglist == NULL)
                {
                    error("ERROR: couldn't allocate for taglist");
                    goto error;
                }
            }                
            else if(strcasecmp(usage_ent->taglist, "all") == 0)
            {
                free(usage_ent->taglist);
                usage_ent->taglist = strdup(SSH_GLOBUS_ALL_TAGLIST);
                if (usage_ent->taglist == NULL)
                {
                    error("ERROR: couldn't allocate for taglist");
                    goto error;
                }
            }
            
            usage_ent->target = entry;

            globus_list_insert(&usage_handle_list, usage_ent);
        }
        while(target != NULL);

        free(target_str);
    }
    else
    {
        usage_ent = (ssh_usage_ent_t *) malloc(sizeof(ssh_usage_ent_t));
        if (usage_ent == NULL)
        {
             error("ERROR: couldn't allocate for usage_ent");
             goto error;
        }

        usage_ent->target = target_str;
        usage_ent->taglist = strdup(SSH_GLOBUS_DEFAULT_TAGLIST);
        if (usage_ent->taglist == NULL)
        {
             error("ERROR: couldn't allocate for taglist");
             goto error;
        }

        globus_list_insert(&usage_handle_list, usage_ent);
    }


    for(list = usage_handle_list;
        !globus_list_empty(list);
        list = globus_list_rest(list))
    {
        usage_ent = (ssh_usage_ent_t *) globus_list_first(list);

        usage_ent->handle = NULL;
        debug("USAGE: Initializing (%s) (%s)", usage_ent->target?:"NULL",
                     usage_ent->taglist?:"NULL");
        result = globus_usage_stats_handle_init(
            &usage_ent->handle,
            SSH_GLOBUS_USAGE_ID,
            SSH_GLOBUS_USAGE_VER,
            usage_ent->target);
    }

    return result;

error:
    if (target_str)
    {
        free(target_str); 
        target_str = NULL;
    }
    if (entry)
    {
        free(target_str); 
        target_str = NULL;
    }
    return GLOBUS_FAILURE;
}

void
ssh_usage_stats_close(int disable_usage_stats)
{
    globus_list_t *list;

    if (disable_usage_stats)
	return;

    list = usage_handle_list;
    
    while(!globus_list_empty(list))
    {
        ssh_usage_ent_t *usage_ent;
        
        usage_ent = (ssh_usage_ent_t *) 
            globus_list_remove(&list, list);
    
        if(usage_ent)
        {
            if(usage_ent->handle)
            {
                globus_usage_stats_handle_destroy(usage_ent->handle);
            }
            if(usage_ent->target)
            {
                free(usage_ent->target);
            }
            if(usage_ent->taglist)
            {
                free(usage_ent->taglist);
            }
            free(usage_ent);
        }
    }
    usage_handle_list = NULL;
}

static void
log_usage_stats(char *ssh_release, const char *ssl_release,
                char *method, char *mechanism, const char *clientip,
                char *username, char *userdn)
{
    globus_result_t                     result;
    globus_list_t *                     list;
    ssh_usage_ent_t *                   usage_ent;
    char *                              keys[SSH_GLOBUS_TAGCOUNT];
    char *                              values[SSH_GLOBUS_TAGCOUNT];
    char *                              ptr;
    char *                              key;
    char *                              value;
    int                                 i = 0;
    char *                              save_taglist = NULL;

    for(list = usage_handle_list;
        !globus_list_empty(list);
        list = globus_list_rest(list))
    {
        usage_ent = (ssh_usage_ent_t *) globus_list_first(list);

        if(!usage_ent || usage_ent->handle == NULL)
            return;
        
        if(save_taglist == NULL || 
            strcmp(save_taglist, usage_ent->taglist) != 0)
        {
            save_taglist = usage_ent->taglist;
            
            ptr = usage_ent->taglist;
            i = 0;
            while(ptr && *ptr)
            {
                switch(*ptr)
                {
                  case SSH_GLOBUS_USAGE_SSH_VER:
                    key = "SSH_VER";
                    value = ssh_release;
                    break;
    
                  case SSH_GLOBUS_USAGE_SSL_VER:
                    key = "SSL_VER";
                    value = (char *) ssl_release;
                    break;
    
                  case SSH_GLOBUS_USAGE_METHOD:
                    key = "METHOD";
                    value = method;
                    break;
    
                  case SSH_GLOBUS_USAGE_MECHANISM:
                    key = "MECH";
                    value = mechanism?:"";
                    break;
    
                  case SSH_GLOBUS_USAGE_CLIENTIP:
                    key = "CLIENTIP";
                    value = (char *) clientip?:"";
                    break;
    
                  case SSH_GLOBUS_USAGE_USERNAME:
                    key = "USER";
                    value = username?:"";
                    break;
    
                  case SSH_GLOBUS_USAGE_USERDN:
                    key = "USERDN";
                    value = userdn?:"";
                    break;
    
                  default:
                    key = NULL;
                    value = NULL;
                    break;
                }
                
                if(key != NULL && value != NULL)
                {
                    keys[i] = key;
                    values[i] = value;
                    i++;
                }
                
                ptr++;
            }
        }

#ifdef HAVE_GLOBUS_USAGE_SEND_ARRAY
        result = globus_usage_stats_send_array(
            usage_ent->handle, i, keys, values);
#else
        if (i)
            result = globus_usage_stats_send(
                usage_ent->handle, i,
                i>0?keys[0]:NULL, i>0?values[0]:NULL,
                i>1?keys[1]:NULL, i>1?values[1]:NULL,
                i>2?keys[2]:NULL, i>2?values[2]:NULL,
                i>3?keys[3]:NULL, i>3?values[3]:NULL,
                i>4?keys[4]:NULL, i>4?values[4]:NULL,
                i>5?keys[5]:NULL, i>5?values[5]:NULL,
                i>6?keys[6]:NULL, i>6?values[6]:NULL);
#endif /* HAVE_GLOBUS_USAGE_SEND_ARRAY */
    }
    
    return;
}
#endif /* HAVE_GLOBUS_USAGE */

void
ssh_globus_send_usage_metrics(char *ssh_release, const char *ssl_release,
                              char *method, char *mechanism, const char *client_ip,
                              char *username, char *userdn)
{
#ifdef HAVE_GLOBUS_USAGE

    log_usage_stats(ssh_release, ssl_release, method, mechanism,
                    client_ip, username, userdn);

#endif /* HAVE_GLOBUS_USAGE */
}
Commit	Line	Data
9f2c8cb9	1	/*
	2	* Copyright 2009 The Board of Trustees of the University
	3	* of Illinois. See the LICENSE file for detailed license information.
	4	*
	5	* Portions, specifically log_usage_stats(), ssh_usage_stats_init(),
	6	* ssh_usage_stats_close(), ssh_usage_ent_s, ssh_usage_tag_e and
	7	* TAG #defines were based on those from Usage Metrics portions of:
	8	* gridftp/server/source/globus_i_gfs_log.c
	9	*
	10	* Copyright 1999-2006 University of Chicago
	11	*
	12	* Licensed under the Apache License, Version 2.0 (the "License");
	13	* you may not use this file except in compliance with the License.
	14	* You may obtain a copy of the License at
	15	*
	16	* http://www.apache.org/licenses/LICENSE-2.0
	17	*
	18	* Unless required by applicable law or agreed to in writing, software
	19	* distributed under the License is distributed on an "AS IS" BASIS,
	20	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	21	* See the License for the specific language governing permissions and
	22	* limitations under the License.
	23	*/
	24
	25	#include <stdarg.h>
	26
	27	#include "log.h"
	28	#include "ssh-globus-usage.h"
	29
	30	#ifdef HAVE_GLOBUS_USAGE
	31
	32	static globus_list_t *usage_handle_list = NULL;
	33
	34	#define SSH_GLOBUS_USAGE_ID 12
	35	#define SSH_GLOBUS_USAGE_VER 0
	36
	37	#define SSH_GLOBUS_DEFAULT_TAGLIST "VvMm"
	38	#define SSH_GLOBUS_ALL_TAGLIST "VvMmIuU"
	39	#define SSH_GLOBUS_TAGCOUNT 25
	40
	41	typedef enum ssh_usage_tag_e
	42	{
	43	SSH_GLOBUS_USAGE_SSH_VER = 'V',
	44	SSH_GLOBUS_USAGE_SSL_VER = 'v',
	45	SSH_GLOBUS_USAGE_METHOD = 'M',
	46	SSH_GLOBUS_USAGE_MECHANISM = 'm',
	47	SSH_GLOBUS_USAGE_CLIENTIP = 'I',
	48	SSH_GLOBUS_USAGE_USERNAME = 'u',
	49	SSH_GLOBUS_USAGE_USERDN = 'U'
	50	/* !! ADD to ALL_TAGLIST above and to globus_usage_stats_send()
	51	invocation below when adding here */
	52	} ssh_usage_tag_t;
	53
	54	typedef struct ssh_usage_ent_s
	55	{
	56	globus_usage_stats_handle_t handle;
	57	char * target;
	58	char * taglist;
	59	} ssh_usage_ent_t;
	60
	61
	62	globus_result_t
	63	ssh_usage_stats_init(int disable_usage_stats, char *usage_stats_targets)
	64	{
65	globus_result_t result;
66	char * target_str = NULL;
67	char * ptr = ptr;
68	char * target = NULL;
69	char * entry = NULL;
70	globus_list_t * list = NULL;
71	ssh_usage_ent_t * usage_ent = NULL;
72
73	if (disable_usage_stats)
74	return GLOBUS_SUCCESS;
75
76	result = globus_module_activate(GLOBUS_USAGE_MODULE);
77	if (result != GLOBUS_SUCCESS)
78	{
79	error("ERROR: couldn't activate USAGE module");
80	return result;
81	}
82
83	if (!usage_stats_targets \|\|
84	!strcasecmp(usage_stats_targets, "default"))
85	target_str = strdup(CILOGON_COLLECTOR);
86	else
87	target_str = strdup(usage_stats_targets);
88
89	if (target_str == NULL)
90	{
91	error("ERROR: strdup failure for target_str");
92	goto error;
93	}
94	debug("Processing usage_stats_target (%s)\n", target_str);
95
96	if(target_str && strchr(target_str, '!'))
97	{
98	target = target_str;
99
100	do {
101	usage_ent = (ssh_usage_ent_t *) malloc(sizeof(ssh_usage_ent_t));
102	if (usage_ent == NULL)
103	{
104	error("ERROR: couldn't allocate for ssh_usage_ent_t");
105	goto error;
106	}
107
108	if ((ptr = strchr(target, ',')) != NULL)
109	*ptr = '\0';
110
111	entry = strdup(target);
112	if (entry == NULL)
113	{
114	error("ERROR: strdup failure for target");
115	goto error;
116	}
117
118	if (ptr)
119	target = ptr + 1;
120	else
121	target = NULL;
122
123	if((ptr = strchr(entry, '!')) != NULL)
124	{
125	*ptr = '\0';
126	usage_ent->taglist = strdup(ptr + 1);
127	if (usage_ent->taglist == NULL)
128	{
129	error("ERROR: strdup failure for taglist");
130	goto error;
131	}
132	if(strlen(usage_ent->taglist) > SSH_GLOBUS_TAGCOUNT)
133	{
134	usage_ent->taglist[SSH_GLOBUS_TAGCOUNT + 1] = '\0';
135	}
136	}
137	else
138	{
139	usage_ent->taglist = strdup(SSH_GLOBUS_DEFAULT_TAGLIST);
140	if (usage_ent->taglist == NULL)
141	{
142	error("ERROR: couldn't allocate for taglist");
143	goto error;
144	}
145	}
146
147	if(strcasecmp(usage_ent->taglist, "default") == 0)
148	{
149	free(usage_ent->taglist);
150	usage_ent->taglist = strdup(SSH_GLOBUS_DEFAULT_TAGLIST);
151	if (usage_ent->taglist == NULL)
152	{
153	error("ERROR: couldn't allocate for taglist");
154	goto error;
155	}
156	}
157	else if(strcasecmp(usage_ent->taglist, "all") == 0)
158	{
159	free(usage_ent->taglist);
160	usage_ent->taglist = strdup(SSH_GLOBUS_ALL_TAGLIST);
161	if (usage_ent->taglist == NULL)
162	{
163	error("ERROR: couldn't allocate for taglist");
164	goto error;
165	}
166	}
167
168	usage_ent->target = entry;
169
170	globus_list_insert(&usage_handle_list, usage_ent);
171	}
172	while(target != NULL);
173
174	free(target_str);
175	}
176	else
177	{
178	usage_ent = (ssh_usage_ent_t *) malloc(sizeof(ssh_usage_ent_t));
179	if (usage_ent == NULL)
180	{
181	error("ERROR: couldn't allocate for usage_ent");
182	goto error;
183	}
184
185	usage_ent->target = target_str;
186	usage_ent->taglist = strdup(SSH_GLOBUS_DEFAULT_TAGLIST);
187	if (usage_ent->taglist == NULL)
188	{
189	error("ERROR: couldn't allocate for taglist");
190	goto error;
191	}
192
193	globus_list_insert(&usage_handle_list, usage_ent);
194	}
195
196
197	for(list = usage_handle_list;
198	!globus_list_empty(list);
199	list = globus_list_rest(list))
200	{
201	usage_ent = (ssh_usage_ent_t *) globus_list_first(list);
202
203	usage_ent->handle = NULL;
204	debug("USAGE: Initializing (%s) (%s)", usage_ent->target?:"NULL",
205	usage_ent->taglist?:"NULL");
206	result = globus_usage_stats_handle_init(
207	&usage_ent->handle,
208	SSH_GLOBUS_USAGE_ID,
209	SSH_GLOBUS_USAGE_VER,
210	usage_ent->target);
211	}
212
213	return result;
214
215	error:
216	if (target_str)
217	{
218	free(target_str);
219	target_str = NULL;
220	}
221	if (entry)
222	{
223	free(target_str);
224	target_str = NULL;
225	}
226	return GLOBUS_FAILURE;
227	}
228
229	void
230	ssh_usage_stats_close(int disable_usage_stats)
231	{
232	globus_list_t *list;
233
234	if (disable_usage_stats)
235	return;
236
237	list = usage_handle_list;
238
239	while(!globus_list_empty(list))
240	{
241	ssh_usage_ent_t *usage_ent;
242
243	usage_ent = (ssh_usage_ent_t *)
244	globus_list_remove(&list, list);
245
246	if(usage_ent)
247	{
248	if(usage_ent->handle)
249	{
250	globus_usage_stats_handle_destroy(usage_ent->handle);
251	}
252	if(usage_ent->target)
253	{
254	free(usage_ent->target);
255	}
256	if(usage_ent->taglist)
257	{
258	free(usage_ent->taglist);
259	}
260	free(usage_ent);
261	}
262	}
263	usage_handle_list = NULL;
264	}
265
266	static void
267	log_usage_stats(char ssh_release, const char ssl_release,
268	char method, char mechanism, const char *clientip,
269	char username, char userdn)
270	{
271	globus_result_t result;
272	globus_list_t * list;
273	ssh_usage_ent_t * usage_ent;
274	char * keys[SSH_GLOBUS_TAGCOUNT];
275	char * values[SSH_GLOBUS_TAGCOUNT];
276	char * ptr;
277	char * key;
278	char * value;
279	int i = 0;
280	char * save_taglist = NULL;
281
282	for(list = usage_handle_list;
283	!globus_list_empty(list);
284	list = globus_list_rest(list))
285	{
286	usage_ent = (ssh_usage_ent_t *) globus_list_first(list);
287
288	if(!usage_ent \|\| usage_ent->handle == NULL)
289	return;
290
291	if(save_taglist == NULL \|\|
292	strcmp(save_taglist, usage_ent->taglist) != 0)
293	{
294	save_taglist = usage_ent->taglist;
295
296	ptr = usage_ent->taglist;
297	i = 0;
298	while(ptr && *ptr)
299	{
300	switch(*ptr)
301	{
302	case SSH_GLOBUS_USAGE_SSH_VER:
303	key = "SSH_VER";
304	value = ssh_release;
305	break;
306
307	case SSH_GLOBUS_USAGE_SSL_VER:
308	key = "SSL_VER";
309	value = (char *) ssl_release;
310	break;
311
312	case SSH_GLOBUS_USAGE_METHOD:
313	key = "METHOD";
314	value = method;
315	break;
316
317	case SSH_GLOBUS_USAGE_MECHANISM:
318	key = "MECH";
319	value = mechanism?:"";
320	break;
321
322	case SSH_GLOBUS_USAGE_CLIENTIP:
323	key = "CLIENTIP";
324	value = (char *) clientip?:"";
325	break;
326
327	case SSH_GLOBUS_USAGE_USERNAME:
328	key = "USER";
329	value = username?:"";
330	break;
331
332	case SSH_GLOBUS_USAGE_USERDN:
333	key = "USERDN";
334	value = userdn?:"";
335	break;
336
337	default:
338	key = NULL;
339	value = NULL;
340	break;
341	}
342
343	if(key != NULL && value != NULL)
344	{
345	keys[i] = key;
346	values[i] = value;
347	i++;
348	}
349
350	ptr++;
351	}
352	}
353
354	#ifdef HAVE_GLOBUS_USAGE_SEND_ARRAY
355	result = globus_usage_stats_send_array(
356	usage_ent->handle, i, keys, values);
357	#else
358	if (i)
359	result = globus_usage_stats_send(
360	usage_ent->handle, i,
361	i>0?keys[0]:NULL, i>0?values[0]:NULL,
362	i>1?keys[1]:NULL, i>1?values[1]:NULL,
363	i>2?keys[2]:NULL, i>2?values[2]:NULL,
364	i>3?keys[3]:NULL, i>3?values[3]:NULL,
365	i>4?keys[4]:NULL, i>4?values[4]:NULL,
366	i>5?keys[5]:NULL, i>5?values[5]:NULL,
367	i>6?keys[6]:NULL, i>6?values[6]:NULL);
368	#endif /* HAVE_GLOBUS_USAGE_SEND_ARRAY */
369	}
370
371	return;
372	}
373	#endif /* HAVE_GLOBUS_USAGE */
374
375	void
376	ssh_globus_send_usage_metrics(char ssh_release, const char ssl_release,
377	char method, char mechanism, const char *client_ip,
378	char username, char userdn)
379	{
380	#ifdef HAVE_GLOBUS_USAGE
381
382	log_usage_stats(ssh_release, ssl_release, method, mechanism,
383	client_ip, username, userdn);
384
385	#endif /* HAVE_GLOBUS_USAGE */
386	}