yaffs Modified the make file to work with new name changes.
[yaffs2.git] / yaffs_nameval.c
1 /*
2  * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
3  *
4  * Copyright (C) 2002-2010 Aleph One Ltd.
5  *   for Toby Churchill Ltd and Brightstar Engineering
6  *
7  * Created by Charles Manning <charles@aleph1.co.uk>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  */
13
14 /*
15  * This simple implementation of a name-value store assumes a small number of values and fits
16  * into a small finite buffer.
17  *
18  * Each attribute is stored as a record:
19  *  sizeof(int) bytes   record size.
20  *  strnlen+1 bytes name null terminated.
21  *  nbytes    value.
22  *  ----------
23  *  total size  stored in record size 
24  *
25  * This code has not been tested with unicode yet.
26  */
27
28 #include "yaffs_nameval.h"
29
30 #include "yportenv.h"
31
32 static int nval_find(const char *xb, int xb_size, const YCHAR * name,
33                      int *exist_size)
34 {
35         int pos = 0;
36         int size;
37
38         memcpy(&size, xb, sizeof(int));
39         while (size > 0 && (size < xb_size) && (pos + size < xb_size)) {
40                 if (yaffs_strncmp
41                     ((YCHAR *) (xb + pos + sizeof(int)), name, size) == 0) {
42                         if (exist_size)
43                                 *exist_size = size;
44                         return pos;
45                 }
46                 pos += size;
47                 if (pos < xb_size - sizeof(int))
48                         memcpy(&size, xb + pos, sizeof(int));
49                 else
50                         size = 0;
51         }
52         if (exist_size)
53                 *exist_size = 0;
54         return -1;
55 }
56
57 static int nval_used(const char *xb, int xb_size)
58 {
59         int pos = 0;
60         int size;
61
62         memcpy(&size, xb + pos, sizeof(int));
63         while (size > 0 && (size < xb_size) && (pos + size < xb_size)) {
64                 pos += size;
65                 if (pos < xb_size - sizeof(int))
66                         memcpy(&size, xb + pos, sizeof(int));
67                 else
68                         size = 0;
69         }
70         return pos;
71 }
72
73 int nval_del(char *xb, int xb_size, const YCHAR * name)
74 {
75         int pos = nval_find(xb, xb_size, name, NULL);
76         int size;
77
78         if (pos >= 0 && pos < xb_size) {
79                 /* Find size, shift rest over this record, then zero out the rest of buffer */
80                 memcpy(&size, xb + pos, sizeof(int));
81                 memcpy(xb + pos, xb + pos + size, xb_size - (pos + size));
82                 memset(xb + (xb_size - size), 0, size);
83                 return 0;
84         } else
85                 return -ENODATA;
86 }
87
88 int nval_set(char *xb, int xb_size, const YCHAR * name, const char *buf,
89              int bsize, int flags)
90 {
91         int pos;
92         int namelen = yaffs_strnlen(name, xb_size);
93         int reclen;
94         int size_exist = 0;
95         int space;
96         int start;
97
98         pos = nval_find(xb, xb_size, name, &size_exist);
99
100         if (flags & XATTR_CREATE && pos >= 0)
101                 return -EEXIST;
102         if (flags & XATTR_REPLACE && pos < 0)
103                 return -ENODATA;
104
105         start = nval_used(xb, xb_size);
106         space = xb_size - start + size_exist;
107
108         reclen = (sizeof(int) + namelen + 1 + bsize);
109
110         if (reclen > space)
111                 return -ENOSPC;
112
113         if (pos >= 0) {
114                 nval_del(xb, xb_size, name);
115                 start = nval_used(xb, xb_size);
116         }
117
118         pos = start;
119
120         memcpy(xb + pos, &reclen, sizeof(int));
121         pos += sizeof(int);
122         yaffs_strncpy((YCHAR *) (xb + pos), name, reclen);
123         pos += (namelen + 1);
124         memcpy(xb + pos, buf, bsize);
125         return 0;
126 }
127
128 int nval_get(const char *xb, int xb_size, const YCHAR * name, char *buf,
129              int bsize)
130 {
131         int pos = nval_find(xb, xb_size, name, NULL);
132         int size;
133
134         if (pos >= 0 && pos < xb_size) {
135
136                 memcpy(&size, xb + pos, sizeof(int));
137                 pos += sizeof(int);     /* advance past record length */
138                 size -= sizeof(int);
139
140                 /* Advance over name string */
141                 while (xb[pos] && size > 0 && pos < xb_size) {
142                         pos++;
143                         size--;
144                 }
145                 /*Advance over NUL */
146                 pos++;
147                 size--;
148
149                 if (size <= bsize) {
150                         memcpy(buf, xb + pos, size);
151                         return size;
152                 }
153
154         }
155         if (pos >= 0)
156                 return -ERANGE;
157         else
158                 return -ENODATA;
159 }
160
161 int nval_list(const char *xb, int xb_size, char *buf, int bsize)
162 {
163         int pos = 0;
164         int size;
165         int name_len;
166         int ncopied = 0;
167         int filled = 0;
168
169         memcpy(&size, xb + pos, sizeof(int));
170         while (size > sizeof(int) && size <= xb_size && (pos + size) < xb_size
171                && !filled) {
172                 pos += sizeof(int);
173                 size -= sizeof(int);
174                 name_len = yaffs_strnlen((YCHAR *) (xb + pos), size);
175                 if (ncopied + name_len + 1 < bsize) {
176                         memcpy(buf, xb + pos, name_len * sizeof(YCHAR));
177                         buf += name_len;
178                         *buf = '\0';
179                         buf++;
180                         if (sizeof(YCHAR) > 1) {
181                                 *buf = '\0';
182                                 buf++;
183                         }
184                         ncopied += (name_len + 1);
185                 } else
186                         filled = 1;
187                 pos += size;
188                 if (pos < xb_size - sizeof(int))
189                         memcpy(&size, xb + pos, sizeof(int));
190                 else
191                         size = 0;
192         }
193         return ncopied;
194 }
195
196 int nval_hasvalues(const char *xb, int xb_size)
197 {
198         return nval_used(xb, xb_size) > 0;
199 }