← Back to branch summary

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

« back to all changes in this revision

Viewing changes to trampoline/norm.c

  • Committer: drtomc
  • Date: 2008-01-30 09:15:05 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:334
WIP only!
Some path normalization code. We need this because our current path tests are
inadequate, and we'll need them in a couple of places, so I figured it was
time to do it properly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
#if 0
 
9
struct stack_t
 
10
{
 
11
    const char** items;
 
12
    size_t capacity;
 
13
    size_t top;
 
14
};
 
15
typedef stack_t Stack;
 
16
 
 
17
Stack* new_stack()
 
18
{
 
19
    Stack* s = (Stack*) malloc(sizeof(Stack));
 
20
    if (!s)
 
21
    {
 
22
        fprintf(stderr, "new_stack: Memory allocation failure! (1)\n");
 
23
        exit(1);
 
24
    }
 
25
    s->items = (const char**) malloc(16 * sizeof(const char*));
 
26
    if (!s->items)
 
27
    {
 
28
        fprintf(stderr, "new_stack: Memory allocation failure! (2)\n");
 
29
        exit(1);
 
30
    }   
 
31
    s->capacity = 16;
 
32
    s->top = 0;
 
33
    return s;
 
34
}
 
35
 
 
36
void stack_push(Stack* s,const char* itm)
 
37
{
 
38
    if (s->top == s->capacity)
 
39
    {
 
40
        int c = s->capacity * 2;
 
41
        const char** itms = (const char**) malloc(c * sizeof(const char*));
 
42
        if (!itms)
 
43
        {
 
44
            fprintf(stderr, "stack_push: Memory allocation failure! (1)\n");
 
45
            exit(1);
 
46
        }
 
47
        memcpy(itms, s->items, s->capacity * sizeof(const char*));
 
48
        free(s->items);
 
49
        s->items = itms;
 
50
        s->capacity = c;
 
51
    }
 
52
    s->items[s->top++] = itm;
 
53
}
 
54
 
 
55
const char* stack_pop(Stack* s)
 
56
{
 
57
    if (s->top == 0)
 
58
    {
 
59
        fprintf(stderr, "stack_pop: underflow!\n");
 
60
        exit(1);
 
61
    }
 
62
    return s->items[--(s->top)];
 
63
}
 
64
 
 
65
void old_stack(Stack* s)
 
66
{
 
67
    free(s->items);
 
68
    free(s);
 
69
}
 
70
#endif 0
 
71
 
 
72
 
 
73
/*
 
74
 * Normalize the unix pathname in src eliminating .. sequences
 
75
 * to yield an absolute path. Returns 0 on success, and -1 on
 
76
 * error.
 
77
 */
 
78
int norm(char* dest, int len, const char* src)
 
79
{
 
80
    const char* s = src;
 
81
    int l = strlen(src);
 
82
    char* d = dest;
 
83
    assert(l <= len);
 
84
 
 
85
    if (!*s || (*d++ = *s++) != '/')
 
86
    {
 
87
        dest[0] = '\0';
 
88
        return -1;
 
89
    }
 
90
    while (*s)
 
91
    {
 
92
        const char* t;
 
93
        int l;
 
94
        t = s;
 
95
        while (*s && (*d++ = *s++) != '/') ;
 
96
        l = s - t - 1;
 
97
        if (1) {
 
98
            char x[128];
 
99
            printf("%d\n",l);
 
100
            strncpy(x,t,l);
 
101
            x[l] = 0;
 
102
            fprintf(stderr,"%s\n",x);
 
103
        }
 
104
        if (strncmp(t, "..", l) == 0)
 
105
        {
 
106
            fprintf(stderr,"backtracking...\n");
 
107
            d -= 4; /* /../ */
 
108
            while (d > dest && *--d != '/')
 
109
            {
 
110
                d--;
 
111
            }
 
112
            if (d < dest)
 
113
            {
 
114
                /* underflow: too many .. sequences */
 
115
                dest[0] = '\0';
 
116
                return -1;
 
117
            }
 
118
        }
 
119
    }
 
120
    *d = '\0';
 
121
    fprintf(stderr, "returning: '%s'\n", dest);
 
122
    return 0;
 
123
}