← Back to branch summary

~ubuntu-branches/debian/sid/rlinetd/sid

« back to all changes in this revision

Viewing changes to strings.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Luberda
  • Date: 2010-03-20 18:03:45 UTC
  • mfrom: (2.3.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20100320180345-x1srfbe2tg00ezsf
Tags: 0.7-1
http://bugs.debian.org/526922
* New upstream version.
* Recommend rsyslog instead of sysklogd (closes: #526922).
* update-inetd:
  + add support for enabling, disabling and removing entries;
  + use ucf for managing generated files;
  + ignore ucf files in rlinetd.conf;
  + make appropriate changes in  postinst and postrm scripts.
* Set debhelper compat level to 7
* Standards-Version: 3.8.4 (no changes). 

Show diffs side-by-side

added added

removed removed

Lines of Context:
strings.c
1
 
#include <stdio.h>
2
 
#include <stdlib.h>
3
 
#include <string.h>
4
 
#include <sysexits.h>
5
 
#include <sys/types.h>
6
 
#include <sys/socket.h>
7
 
#include <sys/wait.h>
8
 
#include <netinet/in.h>
9
 
#include <arpa/inet.h>
10
 
#include <time.h>
11
 
 
12
 
#include <config.h>
13
 
 
14
 
#include "db.h"
15
 
#include "error.h"
16
 
#include "rlinetd.h"
17
 
#include "strings.h"
18
 
 
19
 
void loglist_walk(struct rl_instance *inst, struct loglist *l, int c) {
20
 
        int i;
21
 
 
22
 
        for(i = 0; i < c; i++)
23
 
                loglist_build(inst, l + i);
24
 
}
25
 
 
26
 
void string_populate(struct argvtab *a) {
27
 
        int i, len;
28
 
 
29
 
        for(len = 0, i = 0; i < a->argc; i++)
30
 
                len += a->ents[i].len;
31
 
        a->str = malloc(len + 1);
32
 
        if (!a->str)
33
 
                rl_fatal(EX_SOFTWARE, "ABORT - Can't allocate memory");
34
 
}
35
 
 
36
 
void string_build(struct rl_instance *inst, struct argvtab *a) {
37
 
        int i;
38
 
 
39
 
        if(!a->str)
40
 
                string_populate(a);
41
 
        a->str[0] = '\0';
42
 
        for(i = 0; i < a->argc; i++) {
43
 
                loglist_build(inst, a->ents + i);
44
 
                strncat(a->str, a->ents[i].arg, a->ents[i].len);
45
 
        }
46
 
}
47
 
 
48
 
void argv_populate(struct argvtab *a) {
49
 
        int i;
50
 
        
51
 
        a->argv = (char **)calloc(a->argc + 1, sizeof(char *));
52
 
        if (!a->argv)
53
 
                rl_fatal(EX_SOFTWARE, "ABORT - Can't allocate memory");
54
 
        for(i = 0; i < a->argc; i++)
55
 
                a->argv[i] = a->ents[i].arg;
56
 
        a->argv[i] = NULL;
57
 
}
58
 
 
59
 
char **argv_build(struct rl_instance *i, struct argvtab *a) {
60
 
        if(!a->argv)
61
 
                argv_populate(a);
62
 
        loglist_walk(i, a->ents, a->argc);
63
 
        return a->argv;
64
 
}
65
 
 
66
 
void iov_populate(struct argvtab *a) {
67
 
        int i;
68
 
        
69
 
        a->iov = (struct iovec *)calloc(a->argc, sizeof(struct iovec));
70
 
        if (!a->iov)
71
 
                rl_fatal(EX_SOFTWARE, "ABORT - Can't allocate memory");
72
 
        for(i = 0; i < a->argc; i++)
73
 
                a->iov[i].iov_base = a->ents[i].arg;
74
 
}
75
 
 
76
 
struct iovec *iov_build(struct rl_instance *inst, struct argvtab *a) {
77
 
        int i;
78
 
 
79
 
        if(!a->iov)
80
 
                iov_populate(a);
81
 
        for(i = 0; i < a->argc; i++) {
82
 
                loglist_build(inst, a->ents + i);
83
 
                a->iov[i].iov_len = a->ents[i].len;
84
 
        }
85
 
        return a->iov;
86
 
}
87
 
        
88
 
void loglist_build(struct rl_instance *inst, struct loglist *l) {
89
 
        time_t tt;
90
 
        
91
 
        switch(l->type) {
92
 
                case LOG_TEXT:
93
 
                        return;
94
 
                case LOG_SOURCE_IP:
95
 
                        if(!inst->sin) {
96
 
                                strcpy(l->arg, "<unknown>");
97
 
                                l->len = strlen(l->arg);
98
 
                                return;
99
 
                        }
100
 
#ifdef HAVE_INET_NTOP
101
 
                        if(((struct sockaddr_in *)inst->sin)->sin_family == PF_INET) 
102
 
                                inet_ntop(PF_INET, &((struct sockaddr_in *)inst->sin)->sin_addr,
103
 
                                                                        l->arg, 80);
104
 
#ifdef HAVE_SOCKADDR_IN6
105
 
                        else
106
 
                                inet_ntop(PF_INET6, &((struct sockaddr_in6 *)inst->sin)->sin6_addr,
107
 
                                                                        l->arg, 80);
108
 
#endif
109
 
#else                   
110
 
                        strncpy(l->arg, inet_ntoa(((struct sockaddr_in *)inst->sin)->sin_addr), 80);
111
 
#endif                  
112
 
                        l->len = strlen(l->arg);
113
 
                        return;
114
 
                case LOG_SOURCE_PORT:
115
 
                        if(!inst->sin) {
116
 
                                strcpy(l->arg, "<unknown>");
117
 
                                l->len = strlen(l->arg);
118
 
                                return;
119
 
                        }
120
 
                        l->len = snprintf(l->arg, 6, "%d", ntohs(((struct sockaddr_in *)inst->sin)->sin_port));
121
 
                        return;
122
 
                case LOG_CPU:
123
 
                        l->len =
124
 
                                snprintf(l->arg, 10, "%ld",
125
 
                                                                 inst->rusage.ru_utime.tv_sec +
126
 
                                                                 inst->rusage.ru_stime.tv_sec);
127
 
                        return;
128
 
                case LOG_CPU_USER:
129
 
                        l->len =
130
 
                                snprintf(l->arg, 10, "%ld",
131
 
                                                                 inst->rusage.ru_utime.tv_sec);
132
 
                        return;
133
 
                case LOG_CPU_SYSTEM:
134
 
                        l->len =
135
 
                                snprintf(l->arg, 10, "%ld",
136
 
                                                                 inst->rusage.ru_stime.tv_sec);
137
 
                        return;
138
 
                case LOG_RSS:
139
 
                        l->len =
140
 
                                snprintf(l->arg, 10, "%ld",
141
 
                                                                 inst->rusage.ru_maxrss);
142
 
                        return;
143
 
                case LOG_SHMEM:
144
 
                        l->len =
145
 
                                snprintf(l->arg, 10, "%ld",
146
 
                                                                 inst->rusage.ru_ixrss);
147
 
                        return;
148
 
                case LOG_DATA:
149
 
                        l->len =
150
 
                                snprintf(l->arg, 10, "%ld",
151
 
                                                                 inst->rusage.ru_idrss);
152
 
                        return;
153
 
                case LOG_STACK:
154
 
                        l->len =
155
 
                                snprintf(l->arg, 10, "%ld",
156
 
                                                                 inst->rusage.ru_isrss);
157
 
                        return;
158
 
                case LOG_MINFLT:
159
 
                        l->len =
160
 
                                snprintf(l->arg, 10, "%ld",
161
 
                                                                 inst->rusage.ru_minflt);
162
 
                        return;
163
 
                case LOG_MAJFLT:
164
 
                        l->len =
165
 
                                snprintf(l->arg, 10, "%ld",
166
 
                                                                 inst->rusage.ru_majflt);
167
 
                        return;
168
 
                case LOG_SWAPS:
169
 
                        l->len =
170
 
                                snprintf(l->arg, 10, "%ld",
171
 
                                                                 inst->rusage.ru_nswap);
172
 
                        return;
173
 
                case LOG_BIN:
174
 
                        l->len =
175
 
                                snprintf(l->arg, 10, "%ld",
176
 
                                                                 inst->rusage.ru_inblock);
177
 
                        return;
178
 
                case LOG_BOUT:
179
 
                        l->len =
180
 
                                snprintf(l->arg, 10, "%ld",
181
 
                                                                 inst->rusage.ru_oublock);
182
 
                        return;
183
 
                case LOG_MOUT:
184
 
                        l->len =
185
 
                                snprintf(l->arg, 10, "%ld",
186
 
                                                                 inst->rusage.ru_msgsnd);
187
 
                        return;
188
 
                case LOG_MIN:
189
 
                        l->len =
190
 
                                snprintf(l->arg, 10, "%ld",
191
 
                                                                 inst->rusage.ru_msgrcv);
192
 
                        return;
193
 
                case LOG_NSIG:
194
 
                        l->len =
195
 
                                snprintf(l->arg, 10, "%ld",
196
 
                                                                 inst->rusage.ru_nsignals);
197
 
                        return;
198
 
                case LOG_VCSW:
199
 
                        l->len =
200
 
                                snprintf(l->arg, 10, "%ld",
201
 
                                                                 inst->rusage.ru_nvcsw);
202
 
                        return;
203
 
                case LOG_IVCSW:
204
 
                        l->len =
205
 
                                snprintf(l->arg, 10, "%ld",
206
 
                                                                 inst->rusage.ru_nivcsw);
207
 
                        return;
208
 
                case LOG_EXITCODE:
209
 
                        if(WIFEXITED(inst->status)) {
210
 
                                l->len =
211
 
                                        snprintf(l->arg, 6, "%d",
212
 
                                                                         WEXITSTATUS(inst->status));
213
 
                                return;
214
 
                        }
215
 
                        if(WIFSIGNALED(inst->status)) {
216
 
                                l->len =
217
 
                                        snprintf(l->arg, 6, "SIG%d",
218
 
                                                                         WTERMSIG(inst->status));
219
 
                                return;
220
 
                        }
221
 
                        return;                                                                         /* just in case */
222
 
                case LOG_TIME:
223
 
                        l->len =
224
 
                                snprintf(l->arg, 10, "%ld:%02ld:%02ld",
225
 
                                                                 (inst->stop - inst->start) / 3600,
226
 
                                                                 (inst->stop - inst->start) % 3600 / 60,
227
 
                                                                 (inst->stop - inst->start) % 60);
228
 
                        return;
229
 
                case LOG_ATIME:
230
 
                        tt = htonl(time(NULL) + 2208988800UL);
231
 
                        
232
 
                        l->len = sizeof(tt);
233
 
                        memcpy(l->arg, &tt, sizeof(tt)); /* ugh */
234
 
                        break;
235
 
                case LOG_CTIME:
236
 
                        tt = time(NULL);
237
 
                        l->len =
238
 
                                snprintf(l->arg, 34, "%s", ctime(&tt));
239
 
                        break;
240
 
                default:
241
 
                        rl_fatal(EX_SOFTWARE, "Unknown log request");
242
 
        }
243
 
}
244
 
 
245
 
/* vim: set ts=2: */