← 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 07:14:52 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:478
scripts/usrmgr-server: Renamed actions from dashes to underscores.
    (Consistency).
    accept_user returns a dict instead of None.

apps.py: Turned off auth for userservice (otherwise requests can't come thru
    from a user who is not activated; dispatch blocks such requests).
    Userservice does its own auth from now on.

userservice: Now makes the call to usrmgt-server for accept_me.
    Does authentication (since we can't do it at dispatch level).

tos.js: Clicking Accept now makes an Ajax call to userservice to get the
    account activated.

WHAT WORKS: Clicking the button now gets the account activated. There are some
    rough edges and errors won't be handled well.
WHAT DOESN'T: After clicking, the user is left thinking that nothing happened.
    They have to log out and back in again to enable themselves.
    (This is noted in the bug tracker).

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
 
}