← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to bin/trampoline/norm.c

  • Committer: mattgiuca
  • Date: 2008-02-15 04:45:12 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:472
db.py: No longer exceptions if password is not supplied.
makeuser: Converted explicit args into kwargs which are simply forwarded along
    to db. Makeuser db NO LONGER accepts "force" argument (which used to
    delete and replace login rows). This is dangerous, and we have removed the
    delete user functionality altogether - because we never delete users.
makeuser.py (script): Major change. Replaced the command-line interface so it
    now only takes 3 required arguments, and a bunch of optional arguments
    getopts style.
    All the arguments are specified at the top; the rest of the code works
    with these data structures so they are only specified in one place
    (including all the work of putting them into a dict and passing it to the
    database).
    Note that makeuser.py is a *second* point of control for the list of the
    login fields (the other is in db.DB.login_fields_list). This is by design,
    because there is a semantic difference between "what fields are in the db"
    and "what arguments should we accept on the command line".

Show diffs side-by-side

added added

removed removed

Lines of Context:
bin/trampoline/norm.c
1
 
#include <assert.h>
2
 
#include <string.h>
3
 
#include <stdlib.h>
4
 
#include <stdio.h>
5
 
#include <unistd.h>
6
 
#include "norm.h"
7
 
 
8
 
#define SKP()               \
9
 
    do {                    \
10
 
        s++;                \
11
 
    } while (0)
12
 
 
13
 
#define CPY()               \
14
 
    do {                    \
15
 
        *d++ = *s++;        \
16
 
    } while (0)
17
 
 
18
 
#define MRK()               \
19
 
    do {                    \
20
 
        PUSH();             \
21
 
    } while (0)
22
 
 
23
 
#define BKP()               \
24
 
    do {                    \
25
 
        POP();              \
26
 
    } while (0)
27
 
 
28
 
#define BKP2()              \
29
 
    do {                    \
30
 
        POP();              \
31
 
        POP();              \
32
 
    } while (0)
33
 
 
34
 
#define PUSH()              \
35
 
    do {                    \
36
 
        stk[top++] = d;     \
37
 
    } while (0)
38
 
 
39
 
#define POP()               \
40
 
    do {                    \
41
 
        if (top == 0)       \
42
 
        {                   \
43
 
            dest[0] = '\0'; \
44
 
            return -1;      \
45
 
        }                   \
46
 
        d = stk[--top];     \
47
 
    } while (0)
48
 
 
49
 
/*
50
 
 * Normalize the unix pathname in src eliminating . and .. sequences
51
 
 * to yield an absolute path. Returns 0 on success, and -1 on error.
52
 
 */
53
 
int norm(char* dest, int len, const char* src)
54
 
{
55
 
    const char* s = src;
56
 
    char* d = dest;
57
 
    char* stk[256];
58
 
    int top = 0;
59
 
    enum { L0, L1, L2, L3, L4 } state = L0;
60
 
    assert(strlen(src) <= len);
61
 
 
62
 
    while (*s)
63
 
    {
64
 
        char c = *s;
65
 
        enum { slash, dot, other } cls;
66
 
        switch (c)
67
 
        {
68
 
            case '/':
69
 
            {
70
 
                cls = slash;
71
 
                break;
72
 
            }
73
 
            case '.':
74
 
            {
75
 
                cls = dot;
76
 
                break;
77
 
            }
78
 
            default:
79
 
            {
80
 
                cls = other;
81
 
            }
82
 
        }
83
 
        switch (state)
84
 
        {
85
 
            case L0:
86
 
            {
87
 
                switch (cls)
88
 
                {
89
 
                    case slash:
90
 
                    {
91
 
                        CPY();
92
 
                        state = L1;
93
 
                        break;
94
 
                    }
95
 
                    case dot:
96
 
                    case other:
97
 
                    {
98
 
                        dest[0] = '\0';
99
 
                        return -1;
100
 
                    }
101
 
                }
102
 
                break;
103
 
            }
104
 
            case L1:
105
 
            {
106
 
                switch (cls)
107
 
                {
108
 
                    case slash:
109
 
                    {
110
 
                        SKP();
111
 
                        break;
112
 
                    }
113
 
                    case dot:
114
 
                    {
115
 
                        MRK();
116
 
                        CPY();
117
 
                        state = L2;
118
 
                        break;
119
 
                    }
120
 
                    case other:
121
 
                    {
122
 
                        MRK();
123
 
                        CPY();
124
 
                        state = L4;
125
 
                        break;
126
 
                    }
127
 
                }
128
 
                break;
129
 
            }
130
 
            case L2:
131
 
            {
132
 
                switch (cls)
133
 
                {
134
 
                    case slash:
135
 
                    {
136
 
                        BKP();
137
 
                        state = L1;
138
 
                        break;
139
 
                    }
140
 
                    case dot:
141
 
                    {
142
 
                        CPY();
143
 
                        state = L3;
144
 
                        break;
145
 
                    }
146
 
                    case other:
147
 
                    {
148
 
                        CPY();
149
 
                        state = L4;
150
 
                        break;
151
 
                    }
152
 
                }
153
 
                break;
154
 
            }
155
 
            case L3:
156
 
            {
157
 
                switch (cls)
158
 
                {
159
 
                    case slash:
160
 
                    {
161
 
                        BKP2();
162
 
                        state = L1;
163
 
                        break;
164
 
                    }
165
 
                    case dot:
166
 
                    case other:
167
 
                    {
168
 
                        CPY();
169
 
                        state = L4;
170
 
                        break;
171
 
                    }
172
 
                }
173
 
                break;
174
 
            }
175
 
            case L4:
176
 
            {
177
 
                switch (cls)
178
 
                {
179
 
                    case slash:
180
 
                    {
181
 
                        CPY();
182
 
                        state = L1;
183
 
                        break;
184
 
                    }
185
 
                    case dot:
186
 
                    case other:
187
 
                    {
188
 
                        CPY();
189
 
                        break;
190
 
                    }
191
 
                }
192
 
                break;
193
 
            }
194
 
        }
195
 
    }
196
 
    *d = '\0';
197
 
    return 0;
198
 
}