← Back to branch summary

~ubuntu-branches/ubuntu/natty/globus-gridftp-server/natty-updates

« back to all changes in this revision

Viewing changes to globus_i_gfs_log.c

  • Committer: Bazaar Package Importer
  • Author(s): Mattias Ellert
  • Date: 2009-08-07 07:24:28 UTC
  • Revision ID: james.westby@ubuntu.com-20090807072428-0bb06irrkoi81fu1
Tags: upstream-3.17
Import upstream version 3.17

Show diffs side-by-side

added added

removed removed

Lines of Context:
globus_i_gfs_log.c
 
1
/*
 
2
 * Copyright 1999-2006 University of Chicago
 
3
 *
 
4
 * Licensed under the Apache License, Version 2.0 (the "License");
 
5
 * you may not use this file except in compliance with the License.
 
6
 * You may obtain a copy of the License at
 
7
 *
 
8
 * http://www.apache.org/licenses/LICENSE-2.0
 
9
 *
 
10
 * Unless required by applicable law or agreed to in writing, software
 
11
 * distributed under the License is distributed on an "AS IS" BASIS,
 
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
13
 * See the License for the specific language governing permissions and
 
14
 * limitations under the License.
 
15
 */
 
16
 
 
17
#include "globus_i_gridftp_server.h"
 
18
 
 
19
/**
 
20
 * should select logging based on configuration.  log output funcs should
 
21
 * still be usable before this and will output to stderr.
 
22
 *
 
23
 * if this fails, just print to stderr.
 
24
 */
 
25
 
 
26
 
 
27
static globus_logging_handle_t          globus_l_gfs_log_handle = NULL;
 
28
static globus_list_t *                  globus_l_gfs_log_usage_handle_list = NULL;
 
29
static FILE *                           globus_l_gfs_log_file = NULL;
 
30
static FILE *                           globus_l_gfs_transfer_log_file = NULL;
 
31
static globus_bool_t                    globus_l_gfs_log_events = GLOBUS_FALSE;
 
32
 
 
33
#define GLOBUS_L_GFS_USAGE_ID 0
 
34
#define GLOBUS_L_GFS_USAGE_VER 0
 
35
 
 
36
#define GLOBUS_GFS_DEFAULT_TAGLIST "eEvbBNsStcDATaV"
 
37
#define GLOBUS_GFS_ALL_TAGLIST "eEvbBNsStcfiIudCDATaVU"
 
38
#define GLOBUS_GFS_MAX_TAGCOUNT 25
 
39
 
 
40
typedef enum globus_i_gfs_log_usage_tag_e
 
41
{
 
42
    GLOBUS_I_GFS_USAGE_START    = 'e',
 
43
    GLOBUS_I_GFS_USAGE_END      = 'E',
 
44
    GLOBUS_I_GFS_USAGE_VER      = 'v',
 
45
    GLOBUS_I_GFS_USAGE_BUFFER   = 'b',
 
46
    GLOBUS_I_GFS_USAGE_BLOCK    = 'B',
 
47
    GLOBUS_I_GFS_USAGE_NBYTES   = 'N',
 
48
    GLOBUS_I_GFS_USAGE_STREAMS  = 's',
 
49
    GLOBUS_I_GFS_USAGE_STRIPES  = 'S',
 
50
    GLOBUS_I_GFS_USAGE_TYPE     = 't',
 
51
    GLOBUS_I_GFS_USAGE_CODE     = 'c',
 
52
    GLOBUS_I_GFS_USAGE_FILE     = 'f',
 
53
    GLOBUS_I_GFS_USAGE_CLIENTIP = 'i',
 
54
    GLOBUS_I_GFS_USAGE_DATAIP   = 'I',
 
55
    GLOBUS_I_GFS_USAGE_USER     = 'u',
 
56
    GLOBUS_I_GFS_USAGE_USERDN   = 'd',
 
57
    GLOBUS_I_GFS_USAGE_CONFID   = 'C',
 
58
    GLOBUS_I_GFS_USAGE_DSI      = 'D',
 
59
    GLOBUS_I_GFS_USAGE_EM       = 'A',
 
60
    GLOBUS_I_GFS_USAGE_SCHEME   = 'T',
 
61
    GLOBUS_I_GFS_USAGE_APP      = 'a',
 
62
    GLOBUS_I_GFS_USAGE_APPVER   = 'V',
 
63
    GLOBUS_I_GFS_USAGE_SESSID   = 'U'
 
64
    /* !! ADD to ALL_TAGLIST above when adding here */
 
65
} globus_i_gfs_log_usage_tag_t;
 
66
 
 
67
typedef struct globus_l_gfs_log_usage_ent_s
 
68
{
 
69
    globus_usage_stats_handle_t         handle;
 
70
    char *                              target;
 
71
    char *                              taglist;
 
72
} globus_l_gfs_log_usage_ent_t;
 
73
 
 
74
 
 
75
int
 
76
globus_l_gfs_log_matchlevel(
 
77
    char *                              tag)
 
78
{
 
79
    int                                 out = 0;
 
80
    GlobusGFSName(globus_l_gfs_log_matchlevel);
 
81
    GlobusGFSDebugEnter();
 
82
 
 
83
    if(strcasecmp(tag, "ERROR") == 0)
 
84
    {
 
85
        out = GLOBUS_GFS_LOG_ERR;
 
86
    }
 
87
    else if(strcasecmp(tag, "WARN") == 0)
 
88
    {
 
89
        out = GLOBUS_GFS_LOG_WARN;
 
90
    }
 
91
    else if(strcasecmp(tag, "INFO") == 0)
 
92
    {
 
93
        out = GLOBUS_GFS_LOG_INFO;
 
94
    }
 
95
    else if(strcasecmp(tag, "STATUS") == 0)
 
96
    {
 
97
        out = GLOBUS_GFS_LOG_STATUS;
 
98
    }
 
99
    else if(strcasecmp(tag, "DUMP") == 0)
 
100
    {
 
101
        out = GLOBUS_GFS_LOG_DUMP;
 
102
    }
 
103
    else if(strcasecmp(tag, "ALL") == 0)
 
104
    {
 
105
        out = GLOBUS_GFS_LOG_ALL;
 
106
    }
 
107
 
 
108
    GlobusGFSDebugExit();
 
109
    return out;
 
110
}
 
111
 
 
112
 
 
113
static
 
114
globus_result_t
 
115
globus_l_gfs_log_usage_stats_init()
 
116
{
 
117
    globus_result_t                     result;
 
118
    char *                              target_str;
 
119
    char *                              ptr;
 
120
    char *                              target;
 
121
    char *                              entry;
 
122
    globus_list_t *                     list;
 
123
    globus_l_gfs_log_usage_ent_t *      usage_ent;
 
124
 
 
125
    target_str = globus_libc_strdup(
 
126
        globus_i_gfs_config_string("usage_stats_target"));
 
127
 
 
128
    if(target_str && strchr(target_str, '!'))
 
129
    {
 
130
        target = target_str;
 
131
        while((ptr = strchr(target, ',')) != NULL)
 
132
        {
 
133
            usage_ent = (globus_l_gfs_log_usage_ent_t *)
 
134
                globus_malloc(sizeof(globus_l_gfs_log_usage_ent_t));
 
135
 
 
136
            *ptr = '\0';
 
137
            entry = globus_libc_strdup(target);
 
138
            target = ptr + 1;
 
139
 
 
140
            if((ptr = strchr(entry, '!')) != NULL)
 
141
            {
 
142
                *ptr = '\0';
 
143
                usage_ent->taglist = globus_libc_strdup(ptr + 1);
 
144
                if(strlen(usage_ent->taglist) > GLOBUS_GFS_MAX_TAGCOUNT)
 
145
                {
 
146
                    usage_ent->taglist[GLOBUS_GFS_MAX_TAGCOUNT + 1] = '\0';
 
147
                }
 
148
            }
 
149
            else
 
150
            {
 
151
                usage_ent->taglist = 
 
152
                    globus_libc_strdup(GLOBUS_GFS_DEFAULT_TAGLIST);
 
153
            }
 
154
            
 
155
            if(strcasecmp(usage_ent->taglist, "default") == 0)
 
156
            {
 
157
                globus_free(usage_ent->taglist);
 
158
                usage_ent->taglist = 
 
159
                    globus_libc_strdup(GLOBUS_GFS_DEFAULT_TAGLIST);
 
160
            }                
 
161
            else if(strcasecmp(usage_ent->taglist, "all") == 0)
 
162
            {
 
163
                globus_free(usage_ent->taglist);
 
164
                usage_ent->taglist = 
 
165
                    globus_libc_strdup(GLOBUS_GFS_ALL_TAGLIST);
 
166
            }                
 
167
            
 
168
            usage_ent->target = entry;
 
169
 
 
170
            globus_list_insert(&globus_l_gfs_log_usage_handle_list, usage_ent);
 
171
        }
 
172
        if(ptr == NULL)
 
173
        {
 
174
            usage_ent = (globus_l_gfs_log_usage_ent_t *)
 
175
                globus_malloc(sizeof(globus_l_gfs_log_usage_ent_t));
 
176
 
 
177
            entry = globus_libc_strdup(target);
 
178
            target = ptr + 1;
 
179
 
 
180
            if((ptr = strchr(entry, '!')) != NULL)
 
181
            {
 
182
                *ptr = '\0';
 
183
                usage_ent->taglist = globus_libc_strdup(ptr + 1);
 
184
                if(strlen(usage_ent->taglist) > GLOBUS_GFS_MAX_TAGCOUNT)
 
185
                {
 
186
                    usage_ent->taglist[GLOBUS_GFS_MAX_TAGCOUNT + 1] = '\0';
 
187
                }
 
188
            }
 
189
            else
 
190
            {
 
191
                usage_ent->taglist = 
 
192
                    globus_libc_strdup(GLOBUS_GFS_DEFAULT_TAGLIST);
 
193
            }
 
194
 
 
195
            if(strcasecmp(usage_ent->taglist, "default") == 0)
 
196
            {
 
197
                globus_free(usage_ent->taglist);
 
198
                usage_ent->taglist = 
 
199
                    globus_libc_strdup(GLOBUS_GFS_DEFAULT_TAGLIST);
 
200
            }                
 
201
            else if(strcasecmp(usage_ent->taglist, "all") == 0)
 
202
            {
 
203
                globus_free(usage_ent->taglist);
 
204
                usage_ent->taglist = 
 
205
                    globus_libc_strdup(GLOBUS_GFS_ALL_TAGLIST);
 
206
            }                
 
207
 
 
208
            usage_ent->target = entry;
 
209
 
 
210
            globus_list_insert(&globus_l_gfs_log_usage_handle_list, usage_ent);
 
211
        }
 
212
 
 
213
        globus_free(target_str);
 
214
    }
 
215
    else
 
216
    {
 
217
        usage_ent = (globus_l_gfs_log_usage_ent_t *)
 
218
            globus_malloc(sizeof(globus_l_gfs_log_usage_ent_t));
 
219
 
 
220
        usage_ent->target = target_str;
 
221
        usage_ent->taglist = globus_libc_strdup(GLOBUS_GFS_DEFAULT_TAGLIST);
 
222
 
 
223
        globus_list_insert(&globus_l_gfs_log_usage_handle_list, usage_ent);
 
224
    }
 
225
 
 
226
 
 
227
    for(list = globus_l_gfs_log_usage_handle_list;
 
228
        !globus_list_empty(list);
 
229
        list = globus_list_rest(list))
 
230
    {
 
231
        usage_ent = (globus_l_gfs_log_usage_ent_t *) globus_list_first(list);
 
232
 
 
233
        usage_ent->handle = NULL;
 
234
        result = globus_usage_stats_handle_init(
 
235
            &usage_ent->handle,
 
236
            GLOBUS_L_GFS_USAGE_ID,
 
237
            GLOBUS_L_GFS_USAGE_VER,
 
238
            usage_ent->target);
 
239
    }
 
240
 
 
241
    return result;
 
242
}
 
243
 
 
244
 
 
245
void
 
246
globus_i_gfs_log_open()
 
247
{
 
248
    char *                              module;
 
249
    char *                              module_str;
 
250
    globus_logging_module_t *           log_mod;
 
251
    void *                              log_arg = NULL;
 
252
    char *                              logfilename = NULL;
 
253
    char *                              log_filemode = NULL;
 
254
    char *                              logunique = NULL;
 
255
    char *                              log_level = NULL;
 
256
    int                                 log_mask = 0;
 
257
    char *                              ptr;
 
258
    int                                 len;
 
259
    int                                 ctr;
 
260
    char *                              tag;
 
261
    globus_result_t                     result;
 
262
    globus_reltime_t                    flush_interval;
 
263
    globus_size_t                       buffer;
 
264
    GlobusGFSName(globus_i_gfs_log_open);
 
265
    GlobusGFSDebugEnter();
 
266
 
 
267
    GlobusTimeReltimeSet(flush_interval, 5, 0);
 
268
    buffer = 65536;
 
269
 
 
270
    /* parse user supplied log level string */
 
271
    log_level = globus_libc_strdup(globus_i_gfs_config_string("log_level"));
 
272
    if(log_level != NULL)
 
273
    {
 
274
        len = strlen(log_level);
 
275
        for(ctr = 0; ctr < len && isdigit(log_level[ctr]); ctr++);
 
276
        /* just a number, set log level to the supplied level || every level
 
277
            below */
 
278
        if(ctr == len)
 
279
        {
 
280
            log_mask = atoi(log_level);
 
281
            if(log_mask > 1)
 
282
            {
 
283
                log_mask |= (log_mask >> 1) | ((log_mask >> 1)  - 1);
 
284
            }
 
285
        }
 
286
        else
 
287
        {
 
288
            tag = log_level;
 
289
            while((ptr = strchr(tag, ',')) != NULL)
 
290
            {
 
291
                *ptr = '\0';
 
292
                log_mask |= globus_l_gfs_log_matchlevel(tag);
 
293
                tag = ptr + 1;
 
294
            }
 
295
            if(ptr == NULL)
 
296
            {
 
297
                log_mask |= globus_l_gfs_log_matchlevel(tag);
 
298
            }
 
299
        }
 
300
        globus_free(log_level);
 
301
    }
 
302
 
 
303
    module_str = globus_libc_strdup(globus_i_gfs_config_string("log_module"));
 
304
    module = module_str;
 
305
    if(module_str != NULL)
 
306
    {
 
307
        char *                          opts;
 
308
        char *                          end;
 
309
        globus_off_t                    tmp_off;
 
310
        int                             rc;
 
311
 
 
312
        end = module_str + strlen(module_str);
 
313
        ptr = strchr(module_str, ':');
 
314
        if(ptr != NULL)
 
315
        {
 
316
            *ptr = '\0';
 
317
            ptr++;
 
318
 
 
319
            do
 
320
            {
 
321
                opts = ptr;
 
322
                ptr = strchr(opts, ':');
 
323
                if(ptr)
 
324
                {
 
325
                    *ptr = '\0';
 
326
                    ptr++;
 
327
                    if(ptr >= end)
 
328
                    {
 
329
                        ptr = NULL;
 
330
                    }
 
331
                }
 
332
                if(strncasecmp(opts, "buffer=", 7) == 0)
 
333
                {
 
334
                    rc = globus_args_bytestr_to_num(
 
335
                        opts + 7, &tmp_off);
 
336
                    if(rc != 0)
 
337
                    {
 
338
                        fprintf(stderr, "Invalid value for log buffer\n");
 
339
                    }
 
340
                    if(tmp_off == 0)
 
341
                    {
 
342
                        log_mask |= GLOBUS_LOGGING_INLINE;
 
343
                    }
 
344
                    if(tmp_off < 2048)
 
345
                    {
 
346
                         buffer = 2048;
 
347
                    }
 
348
                    else
 
349
                    {
 
350
                        buffer = (globus_size_t) tmp_off;
 
351
                    }
 
352
                }
 
353
                else if(strncasecmp(opts, "interval=", 9) == 0)
 
354
                {
 
355
                    rc = globus_args_bytestr_to_num(
 
356
                        opts + 9, &tmp_off);
 
357
                    if(rc != 0)
 
358
                    {
 
359
                        fprintf(stderr,
 
360
                            "Invalid value for log flush interval\n");
 
361
                    }
 
362
                    GlobusTimeReltimeSet(flush_interval, (int) tmp_off, 0);
 
363
                }
 
364
                else
 
365
                {
 
366
                    fprintf(stderr, "Invalid log module option: %s\n", opts);
 
367
                }
 
368
 
 
369
 
 
370
            } while(ptr && *ptr);
 
371
        }
 
372
    }
 
373
 
 
374
    if(module == NULL || strcmp(module, "stdio") == 0)
 
375
    {
 
376
        log_mod = &globus_logging_stdio_module;
 
377
    }
 
378
    else if(strcmp(module, "syslog") == 0)
 
379
    {
 
380
        log_mod = &globus_logging_syslog_module;
 
381
    }
 
382
    else if(strcmp(module, "stdio_ng") == 0)
 
383
    {
 
384
        log_mod = &globus_logging_stdio_ng_module;
 
385
        globus_l_gfs_log_events = GLOBUS_TRUE;
 
386
        log_mask |= GLOBUS_GFS_LOG_INFO | 
 
387
            GLOBUS_GFS_LOG_WARN | GLOBUS_GFS_LOG_ERR;
 
388
    }
 
389
    else if(strcmp(module, "syslog_ng") == 0)
 
390
    {
 
391
        log_mod = &globus_logging_syslog_ng_module;
 
392
        globus_l_gfs_log_events = GLOBUS_TRUE;
 
393
        log_mask |= GLOBUS_GFS_LOG_INFO | 
 
394
            GLOBUS_GFS_LOG_WARN | GLOBUS_GFS_LOG_ERR;
 
395
    }
 
396
    else
 
397
    {
 
398
        globus_libc_fprintf(stderr,
 
399
            "Invalid logging module specified, using stdio.\n");
 
400
        log_mod = &globus_logging_stdio_module;
 
401
    }
 
402
 
 
403
    if(log_mod == &globus_logging_stdio_module ||
 
404
        log_mod == &globus_logging_stdio_ng_module )
 
405
    {
 
406
        logfilename = globus_i_gfs_config_string("log_single");
 
407
        if(logfilename == NULL)
 
408
        {
 
409
            logunique = globus_i_gfs_config_string("log_unique");
 
410
            if(logunique != NULL)
 
411
            {
 
412
                logfilename = globus_common_create_string(
 
413
                    "%sgridftp.%d.log", logunique, getpid());
 
414
            }
 
415
        }
 
416
        if(logfilename != NULL)
 
417
        {
 
418
            globus_l_gfs_log_file = fopen(logfilename, "a");
 
419
            if(globus_l_gfs_log_file == NULL)
 
420
            {
 
421
                if(!globus_i_gfs_config_bool("inetd"))
 
422
                {
 
423
                    globus_libc_fprintf(stderr,
 
424
                        "Unable to open %s for logging. "
 
425
                        "Using stderr instead.\n", logfilename);
 
426
                    globus_l_gfs_log_file = stderr;
 
427
                }
 
428
            }
 
429
            else
 
430
            {
 
431
                setvbuf(globus_l_gfs_log_file, NULL, _IOLBF, 0);
 
432
                if((log_filemode =
 
433
                    globus_i_gfs_config_string("log_filemode")) != NULL)
 
434
                {
 
435
                    int                     mode = 0;
 
436
                    mode = strtoul(log_filemode, NULL, 0);
 
437
                    chmod(logfilename, mode);
 
438
                }
 
439
            }
 
440
        }
 
441
 
 
442
        if(globus_l_gfs_log_file == NULL)
 
443
        {
 
444
            globus_l_gfs_log_file = stderr;
 
445
        }
 
446
 
 
447
        log_arg = globus_l_gfs_log_file;
 
448
 
 
449
        if(logunique != NULL)
 
450
        {
 
451
            globus_free(logfilename);
 
452
        }
 
453
    }
 
454
 
 
455
    if(!((log_mod == &globus_logging_stdio_module ||
 
456
        log_mod == &globus_logging_stdio_ng_module) && log_arg == NULL))
 
457
    {
 
458
        globus_logging_init(
 
459
            &globus_l_gfs_log_handle,
 
460
            &flush_interval,
 
461
            buffer,
 
462
            log_mask,
 
463
            log_mod,
 
464
            log_arg);
 
465
    }
 
466
 
 
467
    if((logfilename = globus_i_gfs_config_string("log_transfer")) != NULL)
 
468
    {
 
469
        globus_l_gfs_transfer_log_file = fopen(logfilename, "a");
 
470
        if(globus_l_gfs_transfer_log_file == NULL)
 
471
        {
 
472
            if(!globus_i_gfs_config_bool("inetd"))
 
473
            {
 
474
                globus_libc_fprintf(stderr,
 
475
                    "Unable to open %s for transfer logging.\n", logfilename);
 
476
            }
 
477
        }
 
478
        else
 
479
        {
 
480
            setvbuf(globus_l_gfs_transfer_log_file, NULL, _IOLBF, 0);
 
481
            if((log_filemode = globus_i_gfs_config_string("log_filemode")) != 0)
 
482
            {
 
483
                int                     mode = 0;
 
484
                mode = strtoul(log_filemode, NULL, 0);
 
485
                chmod(logfilename, mode);
 
486
            }
 
487
        }
 
488
    }
 
489
 
 
490
    if(!globus_i_gfs_config_bool("disable_usage_stats"))
 
491
    {
 
492
        result = globus_l_gfs_log_usage_stats_init();
 
493
    }
 
494
 
 
495
 
 
496
    if(module_str)
 
497
    {
 
498
        globus_free(module_str);
 
499
    }
 
500
 
 
501
    GlobusGFSDebugExit();
 
502
}
 
503
 
 
504
void
 
505
globus_i_gfs_log_close(void)
 
506
{
 
507
    globus_list_t *                     list;
 
508
    GlobusGFSName(globus_i_gfs_log_close);
 
509
    GlobusGFSDebugEnter();
 
510
 
 
511
    if(globus_l_gfs_log_handle != NULL)
 
512
    {
 
513
        globus_logging_flush(globus_l_gfs_log_handle);
 
514
        globus_logging_destroy(globus_l_gfs_log_handle);
 
515
    }
 
516
    if(globus_l_gfs_log_file != stderr && globus_l_gfs_log_file != NULL)
 
517
    {
 
518
        fclose(globus_l_gfs_log_file);
 
519
        globus_l_gfs_log_file = NULL;
 
520
    }
 
521
    if(globus_l_gfs_transfer_log_file != NULL)
 
522
    {
 
523
        fclose(globus_l_gfs_transfer_log_file);
 
524
        globus_l_gfs_transfer_log_file = NULL;
 
525
    }
 
526
    
 
527
    list = globus_l_gfs_log_usage_handle_list;
 
528
    
 
529
    while(!globus_list_empty(list))
 
530
    {
 
531
        globus_l_gfs_log_usage_ent_t *  usage_ent;
 
532
        
 
533
        usage_ent = (globus_l_gfs_log_usage_ent_t *) 
 
534
            globus_list_remove(&list, list);
 
535
    
 
536
        if(usage_ent)
 
537
        {
 
538
            if(usage_ent->handle)
 
539
            {
 
540
                globus_usage_stats_handle_destroy(usage_ent->handle);
 
541
            }
 
542
            if(usage_ent->target)
 
543
            {
 
544
                globus_free(usage_ent->target);
 
545
            }
 
546
            if(usage_ent->taglist)
 
547
            {
 
548
                globus_free(usage_ent->taglist);
 
549
            }
 
550
            globus_free(usage_ent);
 
551
        }
 
552
    }
 
553
 
 
554
    GlobusGFSDebugExit();
 
555
}
 
556
 
 
557
void
 
558
globus_gfs_log_message(
 
559
    globus_gfs_log_type_t               type,
 
560
    const char *                        format,
 
561
    ...)
 
562
{
 
563
    va_list                             ap;
 
564
    GlobusGFSName(globus_gfs_log_message);
 
565
    GlobusGFSDebugEnter();
 
566
 
 
567
    if(globus_l_gfs_log_handle != NULL && !globus_l_gfs_log_events)
 
568
    {
 
569
        va_start(ap, format);
 
570
        globus_logging_vwrite(globus_l_gfs_log_handle, type, format, ap);
 
571
        va_end(ap);
 
572
    }
 
573
 
 
574
    GlobusGFSDebugExit();
 
575
}
 
576
 
 
577
void
 
578
globus_gfs_log_result(
 
579
    globus_gfs_log_type_t               type,
 
580
    const char *                        lead,
 
581
    globus_result_t                     result)
 
582
{
 
583
    char *                              message;
 
584
    GlobusGFSName(globus_gfs_log_result);
 
585
    GlobusGFSDebugEnter();
 
586
 
 
587
    if(result != GLOBUS_SUCCESS)
 
588
    {
 
589
        message = globus_error_print_friendly(globus_error_peek(result));
 
590
    }
 
591
    else
 
592
    {
 
593
        message = globus_libc_strdup("(unknown error)");
 
594
    }
 
595
    globus_gfs_log_message(type, "%s:\n%s\n", lead, message);
 
596
    globus_free(message);
 
597
 
 
598
    GlobusGFSDebugExit();
 
599
}
 
600
 
 
601
 
 
602
void
 
603
globus_i_gfs_log_tr(
 
604
    char *                              msg,
 
605
    char                                from,
 
606
    char                                to)
 
607
{
 
608
    char *                              ptr;
 
609
    GlobusGFSName(globus_l_gfs_log_tr);
 
610
    GlobusGFSDebugEnter();
 
611
 
 
612
    ptr = strchr(msg, from);
 
613
    while(ptr != NULL)
 
614
    {
 
615
        *ptr = to;
 
616
        ptr = strchr(ptr, from);
 
617
    }
 
618
    GlobusGFSDebugExit();
 
619
}
 
620
 
 
621
 
 
622
void
 
623
globus_gfs_log_event(
 
624
    globus_gfs_log_type_t               type,
 
625
    globus_gfs_log_event_type_t         event_type,
 
626
    const char *                        event_name,
 
627
    globus_result_t                     result,
 
628
    const char *                        format,
 
629
    ...)
 
630
{
 
631
    va_list                             ap;
 
632
    char *                              msg;
 
633
    char *                              tmp = NULL;
 
634
    char *                              startend;
 
635
    char *                              status;
 
636
    char *                              message = NULL;
 
637
    GlobusGFSName(globus_gfs_log_message);
 
638
    GlobusGFSDebugEnter();
 
639
 
 
640
    if(globus_l_gfs_log_handle != NULL && globus_l_gfs_log_events)
 
641
    {
 
642
        if(format)
 
643
        {
 
644
            va_start(ap, format);
 
645
            tmp = globus_common_v_create_string(format, ap);
 
646
            va_end(ap);
 
647
 
 
648
            globus_i_gfs_log_tr(tmp, '\n', ' ');
 
649
        }
 
650
 
 
651
        if(result != GLOBUS_SUCCESS)
 
652
        {
 
653
            message = globus_error_print_friendly(globus_error_peek(result));
 
654
            globus_i_gfs_log_tr(message, '\n', ' ');
 
655
            globus_i_gfs_log_tr(message, '\"', '\'');
 
656
        }
 
657
 
 
658
        switch(event_type)
 
659
        {
 
660
            case GLOBUS_GFS_LOG_EVENT_START:
 
661
                startend = "start";
 
662
                status = NULL;
 
663
                break;
 
664
            case GLOBUS_GFS_LOG_EVENT_END:
 
665
                startend = "end";
 
666
                if(result == GLOBUS_SUCCESS)
 
667
                {
 
668
                    status = " status=0";
 
669
                }
 
670
                else
 
671
                {
 
672
                    status = " status=-1";
 
673
                }
 
674
                break;
 
675
            case GLOBUS_GFS_LOG_EVENT_MESSAGE:
 
676
                startend = "message";
 
677
                status = NULL;
 
678
                break;
 
679
            default:
 
680
                startend = "error";
 
681
                status = " status=-1";
 
682
                break;
 
683
        }
 
684
 
 
685
        msg = globus_common_create_string(
 
686
            "event=globus-gridftp-server%s%s.%s%s%s%s%s%s%s\n",
 
687
            event_name ? "." : "",
 
688
            event_name ? event_name : "",
 
689
            startend,
 
690
            tmp ? " " : "",
 
691
            tmp ? tmp : "",
 
692
            message ? " msg=\"" : "",
 
693
            message ? message : "",
 
694
            message ? "\"" : "",
 
695
            status ? status : "");
 
696
 
 
697
        globus_logging_write(globus_l_gfs_log_handle, type, msg);
 
698
 
 
699
        globus_free(msg);
 
700
        if(tmp)
 
701
        {
 
702
            globus_free(tmp);
 
703
        }
 
704
        if(message)
 
705
        {
 
706
            globus_free(message);
 
707
        }
 
708
    }
 
709
 
 
710
    GlobusGFSDebugExit();
 
711
}
 
712
 
 
713
char *
 
714
globus_i_gfs_log_create_transfer_event_msg(
 
715
    int                                 stripe_count,
 
716
    int                                 stream_count,
 
717
    char *                              dest_ip,
 
718
    globus_size_t                       blksize,
 
719
    globus_size_t                       tcp_bs,
 
720
    const char *                        fname,
 
721
    globus_off_t                        nbytes,
 
722
    char *                              type,
 
723
    char *                              username)
 
724
{
 
725
    char *                              transfermsg;
 
726
    GlobusGFSName(globus_i_gfs_log_transfer);
 
727
    GlobusGFSDebugEnter();
 
728
 
 
729
    transfermsg = globus_common_create_string(
 
730
        "localuser=%s "
 
731
        "file=%s "
 
732
        "tcpbuffer=%ld "
 
733
        "blocksize=%ld "
 
734
        "bytes=%"GLOBUS_OFF_T_FORMAT" "
 
735
        "streams=%d "
 
736
        "stripes=%d "
 
737
        "remoteIP=%s "
 
738
        "type=%s ",
 
739
        username,
 
740
        fname,
 
741
        (long) tcp_bs,
 
742
        (long) blksize,
 
743
        nbytes,
 
744
        stream_count,
 
745
        stripe_count,
 
746
        dest_ip,
 
747
        type);
 
748
 
 
749
    GlobusGFSDebugExit();
 
750
    return transfermsg;
 
751
}
 
752
 
 
753
void
 
754
globus_i_gfs_log_transfer(
 
755
    int                                 stripe_count,
 
756
    int                                 stream_count,
 
757
    struct timeval *                    start_gtd_time,
 
758
    struct timeval *                    end_gtd_time,
 
759
    char *                              dest_ip,
 
760
    globus_size_t                       blksize,
 
761
    globus_size_t                       tcp_bs,
 
762
    const char *                        fname,
 
763
    globus_off_t                        nbytes,
 
764
    int                                 code,
 
765
    char *                              volume,
 
766
    char *                              type,
 
767
    char *                              username)
 
768
{
 
769
    time_t                              start_time_time;
 
770
    time_t                              end_time_time;
 
771
    struct tm *                         tmp_tm_time;
 
772
    struct tm                           start_tm_time;
 
773
    struct tm                           end_tm_time;
 
774
    char                                out_buf[4096];
 
775
    long                                win_size;
 
776
    GlobusGFSName(globus_i_gfs_log_transfer);
 
777
    GlobusGFSDebugEnter();
 
778
 
 
779
    if(globus_l_gfs_transfer_log_file == NULL)
 
780
    {
 
781
        goto err;
 
782
    }
 
783
 
 
784
    start_time_time = (time_t)start_gtd_time->tv_sec;
 
785
    tmp_tm_time = gmtime(&start_time_time);
 
786
    if(tmp_tm_time == NULL)
 
787
    {
 
788
        goto err;
 
789
    }
 
790
    start_tm_time = *tmp_tm_time;
 
791
 
 
792
    end_time_time = (time_t)end_gtd_time->tv_sec;
 
793
    tmp_tm_time = gmtime(&end_time_time);
 
794
    if(tmp_tm_time == NULL)
 
795
    {
 
796
        goto err;
 
797
    }
 
798
    end_tm_time = *tmp_tm_time;
 
799
 
 
800
    if(tcp_bs == 0)
 
801
    {
 
802
        win_size = 0;
 
803
/*      int                             sock;
 
804
        int                             opt_len;
 
805
        int                             opt_dir;
 
806
 
 
807
        if(strcmp(type, "RETR") == 0 || strcmp(type, "ERET") == 0)
 
808
        {
 
809
            opt_dir = SO_SNDBUF;
 
810
            sock = STDOUT_FILENO;
 
811
        }
 
812
        else
 
813
        {
 
814
            opt_dir = SO_RCVBUF;
 
815
            sock = STDIN_FILENO;
 
816
        }
 
817
        opt_len = sizeof(win_size);
 
818
        getsockopt(sock, SOL_SOCKET, opt_dir, &win_size, &opt_len);
 
819
*/
 
820
    }
 
821
    else
 
822
    {
 
823
        win_size = tcp_bs;
 
824
    }
 
825
 
 
826
    sprintf(out_buf,
 
827
        "DATE=%04d%02d%02d%02d%02d%02d.%d "
 
828
        "HOST=%s "
 
829
        "PROG=%s "
 
830
        "NL.EVNT=FTP_INFO "
 
831
        "START=%04d%02d%02d%02d%02d%02d.%d "
 
832
        "USER=%s "
 
833
        "FILE=%s "
 
834
        "BUFFER=%ld "
 
835
        "BLOCK=%ld "
 
836
        "NBYTES=%"GLOBUS_OFF_T_FORMAT" "
 
837
        "VOLUME=%s "
 
838
        "STREAMS=%d "
 
839
        "STRIPES=%d "
 
840
        "DEST=[%s] "
 
841
        "TYPE=%s "
 
842
        "CODE=%d\n",
 
843
        /* end time */
 
844
        end_tm_time.tm_year + 1900,
 
845
        end_tm_time.tm_mon + 1,
 
846
        end_tm_time.tm_mday,
 
847
        end_tm_time.tm_hour,
 
848
        end_tm_time.tm_min,
 
849
        end_tm_time.tm_sec,
 
850
        (int) end_gtd_time->tv_usec,
 
851
        globus_i_gfs_config_string("fqdn"),
 
852
        "globus-gridftp-server",
 
853
        /* start time */
 
854
        start_tm_time.tm_year + 1900,
 
855
        start_tm_time.tm_mon + 1,
 
856
        start_tm_time.tm_mday,
 
857
        start_tm_time.tm_hour,
 
858
        start_tm_time.tm_min,
 
859
        start_tm_time.tm_sec,
 
860
        (int) start_gtd_time->tv_usec,
 
861
        /* other args */
 
862
        username,
 
863
        fname,
 
864
        win_size,
 
865
        (long) blksize,
 
866
        nbytes,
 
867
        volume,
 
868
        stream_count,
 
869
        stripe_count,
 
870
        dest_ip,
 
871
        type,
 
872
        code);
 
873
 
 
874
    fwrite(out_buf, 1, strlen(out_buf), globus_l_gfs_transfer_log_file);
 
875
 
 
876
    GlobusGFSDebugExit();
 
877
    return;
 
878
 
 
879
err:
 
880
    GlobusGFSDebugExitWithError();
 
881
}
 
882
 
 
883
 
 
884
void
 
885
globus_i_gfs_log_usage_stats(
 
886
    struct timeval *                    start_gtd_time,
 
887
    struct timeval *                    end_gtd_time,
 
888
    int                                 stripe_count,
 
889
    int                                 stream_count,
 
890
    globus_size_t                       blksize,
 
891
    globus_size_t                       tcp_bs,
 
892
    globus_off_t                        nbytes,
 
893
    int                                 code,
 
894
    char *                              type,
 
895
    char *                              filename,
 
896
    char *                              dataip,
 
897
    char *                              clientip,
 
898
    char *                              username,
 
899
    char *                              userdn,
 
900
    char *                              app,
 
901
    char *                              appver,
 
902
    char *                              scheme)
 
903
{
 
904
    time_t                              start_time_time;
 
905
    time_t                              end_time_time;
 
906
    struct tm *                         tmp_tm_time;
 
907
    struct tm                           start_tm_time;
 
908
    struct tm                           end_tm_time;
 
909
    char                                start_b[256];
 
910
    char                                end_b[256];
 
911
    char                                dsi_b[256];
 
912
    char                                block_b[256];
 
913
    char                                buffer_b[256];
 
914
    char                                nbytes_b[256];
 
915
    char                                streams_b[256];
 
916
    char                                stripes_b[256];
 
917
    char                                code_b[256];
 
918
    globus_result_t                     result;
 
919
    globus_list_t *                     list;
 
920
    globus_l_gfs_log_usage_ent_t *      usage_ent;
 
921
    char *                              keys[GLOBUS_GFS_MAX_TAGCOUNT];
 
922
    char *                              values[GLOBUS_GFS_MAX_TAGCOUNT];
 
923
    char *                              ptr;
 
924
    char *                              key;
 
925
    char *                              value;
 
926
    char *                              tmp;    
 
927
    int                                 i = 0;
 
928
    char *                              save_taglist = NULL;
 
929
    GlobusGFSName(globus_i_gfs_log_usage_stats);
 
930
    GlobusGFSDebugEnter();
 
931
 
 
932
 
 
933
    for(list = globus_l_gfs_log_usage_handle_list;
 
934
        !globus_list_empty(list);
 
935
        list = globus_list_rest(list))
 
936
    {
 
937
        usage_ent = (globus_l_gfs_log_usage_ent_t *) globus_list_first(list);
 
938
 
 
939
        if(!usage_ent || usage_ent->handle == NULL)
 
940
        {
 
941
            goto err;
 
942
        }
 
943
        
 
944
        if(save_taglist == NULL || 
 
945
            strcmp(save_taglist, usage_ent->taglist) != 0)
 
946
        {
 
947
            save_taglist = usage_ent->taglist;
 
948
            
 
949
            ptr = usage_ent->taglist;
 
950
            i = 0;
 
951
            while(ptr && *ptr)
 
952
            {
 
953
                switch(*ptr)
 
954
                {
 
955
                  case GLOBUS_I_GFS_USAGE_START:
 
956
                    key = "START";
 
957
                    start_time_time = (time_t)start_gtd_time->tv_sec;
 
958
                    tmp_tm_time = gmtime(&start_time_time);
 
959
                    if(tmp_tm_time == NULL)
 
960
                    {
 
961
                        goto err;
 
962
                    }
 
963
                    start_tm_time = *tmp_tm_time;
 
964
                    sprintf(start_b, "%04d%02d%02d%02d%02d%02d.%d",
 
965
                        start_tm_time.tm_year + 1900,
 
966
                        start_tm_time.tm_mon + 1,
 
967
                        start_tm_time.tm_mday,
 
968
                        start_tm_time.tm_hour,
 
969
                        start_tm_time.tm_min,
 
970
                        start_tm_time.tm_sec,
 
971
                        (int) start_gtd_time->tv_usec);
 
972
                    value = start_b;
 
973
                    break;
 
974
    
 
975
                  case GLOBUS_I_GFS_USAGE_END:
 
976
                    key = "END";
 
977
                    end_time_time = (time_t)end_gtd_time->tv_sec;
 
978
                    tmp_tm_time = gmtime(&end_time_time);
 
979
                    if(tmp_tm_time == NULL)
 
980
                    {
 
981
                        goto err;
 
982
                    }
 
983
                    end_tm_time = *tmp_tm_time;
 
984
                    sprintf(end_b, "%04d%02d%02d%02d%02d%02d.%d",
 
985
                        end_tm_time.tm_year + 1900,
 
986
                        end_tm_time.tm_mon + 1,
 
987
                        end_tm_time.tm_mday,
 
988
                        end_tm_time.tm_hour,
 
989
                        end_tm_time.tm_min,
 
990
                        end_tm_time.tm_sec,
 
991
                        (int) end_gtd_time->tv_usec);
 
992
                    value = end_b;
 
993
                    break;
 
994
    
 
995
                  case GLOBUS_I_GFS_USAGE_VER:
 
996
                    key = "VER";
 
997
                    value = globus_i_gfs_config_string("version_string");
 
998
                    break;
 
999
    
 
1000
                  case GLOBUS_I_GFS_USAGE_BUFFER:
 
1001
                    key = "BUFFER";
 
1002
                    sprintf(buffer_b, "%ld", (long) tcp_bs);
 
1003
                    value = buffer_b;
 
1004
                    break;
 
1005
    
 
1006
                  case GLOBUS_I_GFS_USAGE_BLOCK:
 
1007
                    key = "BLOCK";
 
1008
                    sprintf(block_b, "%ld",(long) blksize);
 
1009
                    value = block_b;
 
1010
                    break;
 
1011
    
 
1012
                  case GLOBUS_I_GFS_USAGE_NBYTES:
 
1013
                    key = "NBYTES";
 
1014
                    sprintf(nbytes_b, "%"GLOBUS_OFF_T_FORMAT, nbytes);
 
1015
                    value = nbytes_b;
 
1016
                    break;
 
1017
    
 
1018
                  case GLOBUS_I_GFS_USAGE_STREAMS:
 
1019
                    key = "STREAMS";
 
1020
                    sprintf(streams_b, "%d", stream_count);
 
1021
                    value = streams_b;
 
1022
                    break;
 
1023
    
 
1024
                  case GLOBUS_I_GFS_USAGE_STRIPES:
 
1025
                    key = "STRIPES";
 
1026
                    sprintf(stripes_b, "%d", stripe_count);
 
1027
                    value = stripes_b;
 
1028
                    break;
 
1029
    
 
1030
                  case GLOBUS_I_GFS_USAGE_TYPE:
 
1031
                    key = "TYPE";
 
1032
                    value = type;
 
1033
                    break;
 
1034
    
 
1035
                  case GLOBUS_I_GFS_USAGE_CODE:
 
1036
                    key = "CODE";
 
1037
                    sprintf(code_b, "%d", code);
 
1038
                    value = code_b;
 
1039
                    break;
 
1040
    
 
1041
                  case GLOBUS_I_GFS_USAGE_FILE:
 
1042
                    key = "FILE";
 
1043
                    value = filename;
 
1044
                    break;
 
1045
    
 
1046
                  case GLOBUS_I_GFS_USAGE_CLIENTIP:
 
1047
                    key = "CLIENTIP";
 
1048
                    value = clientip;
 
1049
                    break;
 
1050
    
 
1051
                  case GLOBUS_I_GFS_USAGE_DATAIP:
 
1052
                    key = "DATAIP";
 
1053
                    value = dataip;
 
1054
                    break;
 
1055
    
 
1056
                  case GLOBUS_I_GFS_USAGE_USER:
 
1057
                    key = "USER";
 
1058
                    value = username;
 
1059
                    break;
 
1060
    
 
1061
                  case GLOBUS_I_GFS_USAGE_USERDN:
 
1062
                    key = "USERDN";
 
1063
                    value = userdn;
 
1064
                    break;
 
1065
    
 
1066
                  case GLOBUS_I_GFS_USAGE_CONFID:
 
1067
                    key = "CONFID";
 
1068
                    value = globus_i_gfs_config_string("usage_stats_id");
 
1069
                    break;
 
1070
    
 
1071
                  case GLOBUS_I_GFS_USAGE_DSI:
 
1072
                    key = "DSI";
 
1073
                    tmp = globus_i_gfs_config_string("load_dsi_module");
 
1074
                    strncpy(dsi_b, tmp, sizeof(dsi_b));
 
1075
                    dsi_b[sizeof(dsi_b - 1)] = '\0';
 
1076
                    if((tmp = strchr(dsi_b, ':')) != NULL)
 
1077
                    {
 
1078
                        *tmp = '\0';
 
1079
                    }
 
1080
                    value = dsi_b;
 
1081
                    break;
 
1082
    
 
1083
                  case GLOBUS_I_GFS_USAGE_EM:
 
1084
                    key = "EM";
 
1085
                    value = globus_i_gfs_config_string("acl");
 
1086
                    break;
 
1087
    
 
1088
                  case GLOBUS_I_GFS_USAGE_SCHEME:
 
1089
                    key = "SCHEMA";
 
1090
                    value = scheme;
 
1091
                    break;
 
1092
    
 
1093
                  case GLOBUS_I_GFS_USAGE_APP:
 
1094
                    key = "APP";
 
1095
                    value = app;
 
1096
                    break;
 
1097
    
 
1098
                  case GLOBUS_I_GFS_USAGE_APPVER:
 
1099
                    key = "APPVER";
 
1100
                    value = appver;
 
1101
                    break;
 
1102
    
 
1103
                  case GLOBUS_I_GFS_USAGE_SESSID:
 
1104
                    key = "SESSID";
 
1105
                    value = NULL;
 
1106
                    break;
 
1107
    
 
1108
                  default:
 
1109
                    key = NULL;
 
1110
                    value = NULL;
 
1111
                    break;
 
1112
                }
 
1113
                
 
1114
                if(key != NULL && value != NULL)
 
1115
                {
 
1116
                    keys[i] = key;
 
1117
                    values[i] = value;
 
1118
                    i++;
 
1119
                }
 
1120
                
 
1121
                ptr++;
 
1122
            }
 
1123
        }
 
1124
        
 
1125
        result = globus_usage_stats_send_array(
 
1126
            usage_ent->handle, i, keys, values);
 
1127
        
 
1128
    }
 
1129
    
 
1130
    GlobusGFSDebugExit();
 
1131
    return;
 
1132
 
 
1133
err:
 
1134
    GlobusGFSDebugExitWithError();
 
1135
}
 
1136