[9] | 1 | /* Test24: opendir, readdir, rewinddir, closedir Author: Jan-Mark Wams */
|
---|
| 2 |
|
---|
| 3 | #include <sys/types.h>
|
---|
| 4 | #include <sys/stat.h>
|
---|
| 5 | #include <sys/wait.h>
|
---|
| 6 | #include <string.h>
|
---|
| 7 | #include <stdlib.h>
|
---|
| 8 | #include <unistd.h>
|
---|
| 9 | #include <limits.h>
|
---|
| 10 | #include <fcntl.h>
|
---|
| 11 | #include <dirent.h>
|
---|
| 12 | #include <errno.h>
|
---|
| 13 | #include <time.h>
|
---|
| 14 | #include <stdio.h>
|
---|
| 15 |
|
---|
| 16 | _PROTOTYPE(void main, (int argc, char *argv[]));
|
---|
| 17 | _PROTOTYPE(void chk_dir, (DIR * dirpntr));
|
---|
| 18 | _PROTOTYPE(void test24a, (void));
|
---|
| 19 | _PROTOTYPE(void test24b, (void));
|
---|
| 20 | _PROTOTYPE(void test24c, (void));
|
---|
| 21 | _PROTOTYPE(void makelongnames, (void));
|
---|
| 22 | _PROTOTYPE(void e, (int number));
|
---|
| 23 | _PROTOTYPE(void quit, (void));
|
---|
| 24 |
|
---|
| 25 | #define OVERFLOW_DIR_NR (OPEN_MAX + 1)
|
---|
| 26 | #define MAX_ERROR 4
|
---|
| 27 | #define ITERATIONS 5
|
---|
| 28 |
|
---|
| 29 | #define DIRENT0 ((struct dirent *) NULL)
|
---|
| 30 | #define System(cmd) if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
|
---|
| 31 | #define Chdir(dir) if (chdir(dir) != 0) printf("Can't goto %s\n", dir)
|
---|
| 32 |
|
---|
| 33 | int errct = 0;
|
---|
| 34 | int subtest = 1;
|
---|
| 35 | int superuser;
|
---|
| 36 |
|
---|
| 37 | char MaxName[NAME_MAX + 1]; /* Name of maximum length */
|
---|
| 38 | char MaxPath[PATH_MAX]; /* Same for path */
|
---|
| 39 | char ToLongName[NAME_MAX + 2]; /* Name of maximum +1 length */
|
---|
| 40 | char ToLongPath[PATH_MAX + 1]; /* Same for path, both too long */
|
---|
| 41 |
|
---|
| 42 | void main(argc, argv)
|
---|
| 43 | int argc;
|
---|
| 44 | char *argv[];
|
---|
| 45 | {
|
---|
| 46 | int i, m = 0xFFFF;
|
---|
| 47 |
|
---|
| 48 | sync();
|
---|
| 49 | if (argc == 2) m = atoi(argv[1]);
|
---|
| 50 | printf("Test 24 ");
|
---|
| 51 | fflush(stdout);
|
---|
| 52 | System("rm -rf DIR_24; mkdir DIR_24");
|
---|
| 53 | Chdir("DIR_24");
|
---|
| 54 | makelongnames();
|
---|
| 55 | superuser = (geteuid() == 0);
|
---|
| 56 |
|
---|
| 57 | for (i = 0; i < ITERATIONS; i++) {
|
---|
| 58 | if (m & 0001) test24a();
|
---|
| 59 | if (m & 0002) test24b();
|
---|
| 60 | if (m & 0004) test24c();
|
---|
| 61 | }
|
---|
| 62 | quit();
|
---|
| 63 | }
|
---|
| 64 |
|
---|
| 65 | void test24a()
|
---|
| 66 | { /* Test normal operations. */
|
---|
| 67 | int fd3, fd4, fd5;
|
---|
| 68 | DIR *dirp;
|
---|
| 69 | int j, ret, fd, flags;
|
---|
| 70 | struct stat st1, st2;
|
---|
| 71 | int stat_loc;
|
---|
| 72 | time_t time1;
|
---|
| 73 |
|
---|
| 74 | subtest = 1;
|
---|
| 75 |
|
---|
| 76 | System("rm -rf ../DIR_24/*");
|
---|
| 77 |
|
---|
| 78 | if ((fd = dup(0)) != 3) e(1); /* dup stdin */
|
---|
| 79 | close(fd); /* free the fd again */
|
---|
| 80 | dirp = opendir("/"); /* open "/" */
|
---|
| 81 | if (dirp == ((DIR *) NULL)) e(2); /* has to succseed */
|
---|
| 82 | if ((fd = dup(0)) <= 2) e(3); /* dup stdin */
|
---|
| 83 | if (fd > 3) { /* if opendir() uses fd 3 */
|
---|
| 84 | flags = fcntl(3, F_GETFD); /* get fd fags of 3 */
|
---|
| 85 | if (!(flags & FD_CLOEXEC)) e(4); /* it should be closed on */
|
---|
| 86 | } /* exec..() calls */
|
---|
| 87 | close(fd); /* free the fd again */
|
---|
| 88 | ret = closedir(dirp); /* close, we don't need it */
|
---|
| 89 | if (ret == -1) e(5); /* closedir () unsucces full */
|
---|
| 90 | if (ret != 0) e(6); /* should be 0 or -1 */
|
---|
| 91 | if ((fd = dup(0)) != 3) e(7); /* see if next fd is same */
|
---|
| 92 | close(fd); /* free the fd again */
|
---|
| 93 |
|
---|
| 94 | System("rm -rf foo; mkdir foo");
|
---|
| 95 | Chdir("foo");
|
---|
| 96 | System("touch f1 f2 f3 f4 f5"); /* make f1 .. f5 */
|
---|
| 97 | System("rm f[24]"); /* creat `holes' in entrys */
|
---|
| 98 | Chdir("..");
|
---|
| 99 |
|
---|
| 100 | if ((dirp = opendir("foo")) == ((DIR *) NULL)) e(8); /* open foo */
|
---|
| 101 | chk_dir(dirp); /* test if foo's ok */
|
---|
| 102 | for (j = 0; j < 10; j++) {
|
---|
| 103 | errno = j * 47 % 7; /* there should */
|
---|
| 104 | if (readdir(dirp) != DIRENT0) e(9); /* be nomore dir */
|
---|
| 105 | if (errno != j * 47 % 7) e(10); /* entrys */
|
---|
| 106 | }
|
---|
| 107 | rewinddir(dirp); /* rewind foo */
|
---|
| 108 | chk_dir(dirp); /* test foosok */
|
---|
| 109 | for (j = 0; j < 10; j++) {
|
---|
| 110 | errno = j * 23 % 7; /* there should */
|
---|
| 111 | if (readdir(dirp) != DIRENT0) e(11); /* be nomore dir */
|
---|
| 112 | if (errno != j * 23 % 7) e(12); /* entrys */
|
---|
| 113 | }
|
---|
| 114 | if ((fd4 = creat("foo/f4", 0666)) <= 2) e(13); /* Open a file. */
|
---|
| 115 | System("rm foo/f4"); /* Kill entry. */
|
---|
| 116 | rewinddir(dirp); /* Rewind foo. */
|
---|
| 117 | if ((fd3 = open("foo/f3", O_WRONLY)) <= 2) e(14); /* Open more files. */
|
---|
| 118 | if ((fd5 = open("foo/f5", O_WRONLY)) <= 2) e(15);
|
---|
| 119 | if (write(fd3, "Hello", 6) != 6) e(16);
|
---|
| 120 | if (write(fd4, "Hello", 6) != 6) e(17); /* write some data */
|
---|
| 121 | if (close(fd5) != 0) e(18);
|
---|
| 122 | chk_dir(dirp);
|
---|
| 123 | for (j = 0; j < 10; j++) {
|
---|
| 124 | errno = j * 101 % 7; /* there should */
|
---|
| 125 | if (readdir(dirp) != DIRENT0) e(19); /* be nomore dir */
|
---|
| 126 | if (errno != j * 101 % 7) e(20); /* entrys */
|
---|
| 127 | }
|
---|
| 128 | if (close(fd4) != 0) e(21); /* shouldn't matter */
|
---|
| 129 | if (close(fd3) != 0) e(22); /* when we do this */
|
---|
| 130 | if (closedir(dirp) != 0) e(23); /* close foo again */
|
---|
| 131 |
|
---|
| 132 | Chdir("foo");
|
---|
| 133 | if ((dirp = opendir(".//")) == ((DIR *) NULL)) e(24); /* open foo again */
|
---|
| 134 | Chdir("..");
|
---|
| 135 | chk_dir(dirp); /* foosok? */
|
---|
| 136 | for (j = 0; j < 10; j++) {
|
---|
| 137 | errno = (j * 101) % 7; /* there should */
|
---|
| 138 | if (readdir(dirp) != DIRENT0) e(25); /* be nomore dir */
|
---|
| 139 | if (errno != (j * 101) % 7) e(26); /* entrys */
|
---|
| 140 | }
|
---|
| 141 |
|
---|
| 142 | if (closedir(dirp) != 0) e(27); /* It should be closable */
|
---|
| 143 |
|
---|
| 144 | stat("foo", &st1); /* get stat */
|
---|
| 145 | time(&time1);
|
---|
| 146 | while (time1 >= time((time_t *)0))
|
---|
| 147 | ;
|
---|
| 148 | if ((dirp = opendir("foo")) == ((DIR *) NULL)) e(28); /* open, */
|
---|
| 149 | if (readdir(dirp) == DIRENT0) e(29); /* read and */
|
---|
| 150 | stat("foo", &st2); /* get new stat */
|
---|
| 151 | if (st1.st_atime > st2.st_atime) e(30); /* st_atime check */
|
---|
| 152 |
|
---|
| 153 | switch (fork()) {
|
---|
| 154 | case -1: printf("Can't fork\n"); break;
|
---|
| 155 | case 0:
|
---|
| 156 | rewinddir(dirp); /* rewind childs dirp */
|
---|
| 157 | if (readdir(dirp) == DIRENT0) e(31); /* read should be ok */
|
---|
| 158 | if (closedir(dirp) != 0) e(32); /* close child'd foo */
|
---|
| 159 | exit(0); /* 0 stops here */
|
---|
| 160 | default:
|
---|
| 161 | if (wait(&stat_loc) == -1) e(33); /* PARENT wait()'s */
|
---|
| 162 | break;
|
---|
| 163 | }
|
---|
| 164 | if (closedir(dirp) != 0) e(34); /* close parent's foo */
|
---|
| 165 | }
|
---|
| 166 |
|
---|
| 167 | void test24b()
|
---|
| 168 | {
|
---|
| 169 | /* See what happens with too many dir's open. Check if file size seems ok,
|
---|
| 170 | * and independency.
|
---|
| 171 | */
|
---|
| 172 |
|
---|
| 173 | int i, j; /* i = highest open dir count */
|
---|
| 174 | DIR *dirp[OVERFLOW_DIR_NR], *dp;
|
---|
| 175 | struct dirent *dep, *dep1, *dep2;
|
---|
| 176 | char name[NAME_MAX + 2]; /* buffer for file name, and count */
|
---|
| 177 | int dot = 0, dotdot = 0;
|
---|
| 178 |
|
---|
| 179 | subtest = 2;
|
---|
| 180 |
|
---|
| 181 | System("rm -rf ../DIR_24/*");
|
---|
| 182 |
|
---|
| 183 | for (i = 0; i < OVERFLOW_DIR_NR; i++) {
|
---|
| 184 | dirp[i] = opendir("/");
|
---|
| 185 | if (dirp[i] == ((DIR *) NULL)) {
|
---|
| 186 | if (errno != EMFILE) e(1);
|
---|
| 187 | break;
|
---|
| 188 | }
|
---|
| 189 | }
|
---|
| 190 | if (i <= 4) e(2); /* sounds resanable */
|
---|
| 191 | if (i >= OVERFLOW_DIR_NR) e(3); /* might be to small */
|
---|
| 192 | for (j = 0; j < i; j++) {
|
---|
| 193 | if (closedir(dirp[(j + 5) % i]) != 0) e(4); /* neat! */
|
---|
| 194 | }
|
---|
| 195 |
|
---|
| 196 | /* Now check if number of bytes in d_name can go up till NAME_MAX */
|
---|
| 197 | System("rm -rf foo; mkdir foo");
|
---|
| 198 | Chdir("foo");
|
---|
| 199 | name[0] = 0;
|
---|
| 200 | for (i = 0; i <= NAME_MAX; i++) {
|
---|
| 201 | if (strcat(name, "X") != name) e(5);
|
---|
| 202 | close(creat(name, 0666)); /* fails once on */
|
---|
| 203 | } /* XX..XX, 1 too long */
|
---|
| 204 | Chdir("..");
|
---|
| 205 | /* Now change i-th X to Y in name buffer record file of length i. */
|
---|
| 206 | if ((dp = opendir("foo")) == ((DIR *) NULL)) e(6);
|
---|
| 207 | while ((dep = readdir(dp)) != DIRENT0) {
|
---|
| 208 | if (strcmp("..", dep->d_name) == 0)
|
---|
| 209 | dotdot++;
|
---|
| 210 | else if (strcmp(".", dep->d_name) == 0)
|
---|
| 211 | dot++;
|
---|
| 212 | else
|
---|
| 213 | name[strlen(dep->d_name)] += 1; /* 'X' + 1 == 'Y' */
|
---|
| 214 | }
|
---|
| 215 | if (closedir(dp) != 0) e(7);
|
---|
| 216 | for (i = 1; i <= NAME_MAX; i++) { /* Check if every length */
|
---|
| 217 | if (name[i] != 'Y') e(8); /* has been seen once. */
|
---|
| 218 | }
|
---|
| 219 |
|
---|
| 220 | /* Check upper and lower bound. */
|
---|
| 221 | if (name[0] != 'X') e(9);
|
---|
| 222 | if (name[NAME_MAX + 1] != '\0') e(10);
|
---|
| 223 |
|
---|
| 224 | /* Now check if two simultaniouse open dirs do the same */
|
---|
| 225 | if ((dirp[1] = opendir("foo")) == ((DIR *) NULL)) e(11);
|
---|
| 226 | if ((dirp[2] = opendir("foo")) == ((DIR *) NULL)) e(12);
|
---|
| 227 | if ((dep1 = readdir(dirp[1])) == DIRENT0) e(13);
|
---|
| 228 | if ((dep2 = readdir(dirp[2])) == DIRENT0) e(14);
|
---|
| 229 | if (dep1->d_name == dep2->d_name) e(15); /* 1 & 2 Should be */
|
---|
| 230 | strcpy(name, dep2->d_name); /* differand buffers */
|
---|
| 231 | if (strcmp(dep1->d_name, name) != 0) e(16); /* But hold the same */
|
---|
| 232 | if ((dep1 = readdir(dirp[1])) == DIRENT0) e(17);
|
---|
| 233 | if ((dep1 = readdir(dirp[1])) == DIRENT0) e(18); /* lose some entries */
|
---|
| 234 | if ((dep1 = readdir(dirp[1])) == DIRENT0) e(19); /* Using dirp 1 has */
|
---|
| 235 | if (dep1->d_name == dep2->d_name) e(20); /* no effect on 2 */
|
---|
| 236 | if (strcmp(dep2->d_name, name) != 0) e(21);
|
---|
| 237 | rewinddir(dirp[1]); /* Rewinding dirp 1 */
|
---|
| 238 | if ((dep2 = readdir(dirp[2])) == DIRENT0) e(22); /* can't effect 2 */
|
---|
| 239 | if (strcmp(dep2->d_name, name) == 0) e(23); /* Must be next */
|
---|
| 240 | if (closedir(dirp[1]) != 0) e(24); /* Closing dirp 1 */
|
---|
| 241 | if ((dep2 = readdir(dirp[2])) == DIRENT0) e(25); /* can't effect 2 */
|
---|
| 242 | if (strcmp(dep2->d_name, name) == 0) e(26); /* Must be next */
|
---|
| 243 | if (closedir(dirp[2]) != 0) e(27);
|
---|
| 244 | }
|
---|
| 245 |
|
---|
| 246 | void test24c()
|
---|
| 247 | {
|
---|
| 248 | /* Test whether wrong things go wrong right. */
|
---|
| 249 |
|
---|
| 250 | DIR *dirp;
|
---|
| 251 |
|
---|
| 252 | subtest = 3;
|
---|
| 253 |
|
---|
| 254 | System("rm -rf ../DIR_24/*");
|
---|
| 255 |
|
---|
| 256 | if (opendir("foo/bar/nono") != ((DIR *) NULL)) e(1); /* nonexistent */
|
---|
| 257 | if (errno != ENOENT) e(2);
|
---|
| 258 | System("mkdir foo; chmod 677 foo"); /* foo inaccesable */
|
---|
| 259 | if (opendir("foo/bar/nono") != ((DIR *) NULL)) e(3);
|
---|
| 260 | if (superuser) {
|
---|
| 261 | if (errno != ENOENT) e(4); /* su has access */
|
---|
| 262 | System("chmod 377 foo");
|
---|
| 263 | if ((dirp = opendir("foo")) == ((DIR *) NULL)) e(5);
|
---|
| 264 | if (closedir(dirp) != 0) e(6);
|
---|
| 265 | }
|
---|
| 266 | if (!superuser) {
|
---|
| 267 | if (errno != EACCES) e(7); /* we don't ;-) */
|
---|
| 268 | System("chmod 377 foo");
|
---|
| 269 | if (opendir("foo") != ((DIR *) NULL)) e(8);
|
---|
| 270 | }
|
---|
| 271 | System("chmod 777 foo");
|
---|
| 272 |
|
---|
| 273 | if (mkdir(MaxName, 0777) != 0) e(9); /* make longdir */
|
---|
| 274 | if ((dirp = opendir(MaxName)) == ((DIR *) NULL)) e(10); /* open it */
|
---|
| 275 | if (closedir(dirp) != 0) e(11); /* close it */
|
---|
| 276 | if (rmdir(MaxName) != 0) e(12); /* then remove it */
|
---|
| 277 | if ((dirp = opendir(MaxPath)) == ((DIR *) NULL)) e(13); /* open '.' */
|
---|
| 278 | if (closedir(dirp) != 0) e(14); /* close it */
|
---|
| 279 | #if 0 /* XXX - anything could happen with the bad pointer */
|
---|
| 280 | if (closedir(dirp) != -1) e(15); /* close it again */
|
---|
| 281 | if (closedir(dirp) != -1) e(16); /* and again */
|
---|
| 282 | #endif /* 0 */
|
---|
| 283 | if (opendir(ToLongName) != ((DIR *) NULL)) e(17); /* is too long */
|
---|
| 284 | #ifdef _POSIX_NO_TRUNC
|
---|
| 285 | # if _POSIX_NO_TRUNC - 0 != -1
|
---|
| 286 | if (errno != ENAMETOOLONG) e(18);
|
---|
| 287 | # else
|
---|
| 288 | if (errno != ENOENT) e(19);
|
---|
| 289 | # endif
|
---|
| 290 | #else
|
---|
| 291 | # include "error, this case requires dynamic checks and is not handled"
|
---|
| 292 | #endif
|
---|
| 293 | if (opendir(ToLongPath) != ((DIR *) NULL)) e(20); /* path is too long */
|
---|
| 294 | if (errno != ENAMETOOLONG) e(21);
|
---|
| 295 | System("touch foo/abc"); /* make a file */
|
---|
| 296 | if (opendir("foo/abc") != ((DIR *) NULL)) e(22); /* not a dir */
|
---|
| 297 | if (errno != ENOTDIR) e(23);
|
---|
| 298 | }
|
---|
| 299 |
|
---|
| 300 | void chk_dir(dirp) /* dir should contain */
|
---|
| 301 | DIR *dirp; /* (`f1', `f3', `f5', `.', `..') */
|
---|
| 302 | { /* no more, no less */
|
---|
| 303 | int f1 = 0, f2 = 0, f3 = 0, f4 = 0, f5 = 0, /* counters for all */
|
---|
| 304 | other = 0, dot = 0, dotdot = 0; /* possible entrys */
|
---|
| 305 | int i;
|
---|
| 306 | struct dirent *dep;
|
---|
| 307 | char *fname;
|
---|
| 308 | int oldsubtest = subtest;
|
---|
| 309 |
|
---|
| 310 | subtest = 4;
|
---|
| 311 |
|
---|
| 312 | for (i = 0; i < 5; i++) { /* 3 files and `.' and `..' == 5 entrys */
|
---|
| 313 | dep = readdir(dirp);
|
---|
| 314 | if (dep == DIRENT0) { /* not einough */
|
---|
| 315 | if (dep == DIRENT0) e(1);
|
---|
| 316 | break;
|
---|
| 317 | }
|
---|
| 318 | fname = dep->d_name;
|
---|
| 319 | if (strcmp(fname, ".") == 0)
|
---|
| 320 | dot++;
|
---|
| 321 | else if (strcmp(fname, "..") == 0)
|
---|
| 322 | dotdot++;
|
---|
| 323 | else if (strcmp(fname, "f1") == 0)
|
---|
| 324 | f1++;
|
---|
| 325 | else if (strcmp(fname, "f2") == 0)
|
---|
| 326 | f2++;
|
---|
| 327 | else if (strcmp(fname, "f3") == 0)
|
---|
| 328 | f3++;
|
---|
| 329 | else if (strcmp(fname, "f4") == 0)
|
---|
| 330 | f4++;
|
---|
| 331 | else if (strcmp(fname, "f5") == 0)
|
---|
| 332 | f5++;
|
---|
| 333 | else
|
---|
| 334 | other++;
|
---|
| 335 | } /* do next dir entry */
|
---|
| 336 |
|
---|
| 337 | if (dot != 1) e(2); /* Check the entrys */
|
---|
| 338 | if (dotdot != 1) e(3);
|
---|
| 339 | if (f1 != 1) e(4);
|
---|
| 340 | if (f3 != 1) e(5);
|
---|
| 341 | if (f5 != 1) e(6);
|
---|
| 342 | if (f2 != 0) e(7);
|
---|
| 343 | if (f4 != 0) e(8);
|
---|
| 344 | if (other != 0) e(9);
|
---|
| 345 |
|
---|
| 346 | subtest = oldsubtest;
|
---|
| 347 | }
|
---|
| 348 |
|
---|
| 349 | void makelongnames()
|
---|
| 350 | {
|
---|
| 351 | register int i;
|
---|
| 352 |
|
---|
| 353 | memset(MaxName, 'a', NAME_MAX);
|
---|
| 354 | MaxName[NAME_MAX] = '\0';
|
---|
| 355 | for (i = 0; i < PATH_MAX - 1; i++) { /* idem path */
|
---|
| 356 | MaxPath[i++] = '.';
|
---|
| 357 | MaxPath[i] = '/';
|
---|
| 358 | }
|
---|
| 359 | MaxPath[PATH_MAX - 1] = '\0';
|
---|
| 360 |
|
---|
| 361 | strcpy(ToLongName, MaxName); /* copy them Max to ToLong */
|
---|
| 362 | strcpy(ToLongPath, MaxPath);
|
---|
| 363 |
|
---|
| 364 | ToLongName[NAME_MAX] = 'a';
|
---|
| 365 | ToLongName[NAME_MAX + 1] = '\0'; /* extend ToLongName by one too many */
|
---|
| 366 | ToLongPath[PATH_MAX - 1] = '/';
|
---|
| 367 | ToLongPath[PATH_MAX] = '\0'; /* inc ToLongPath by one */
|
---|
| 368 | }
|
---|
| 369 |
|
---|
| 370 | void e(n)
|
---|
| 371 | int n;
|
---|
| 372 | {
|
---|
| 373 | int err_num = errno; /* Save in case printf clobbers it. */
|
---|
| 374 |
|
---|
| 375 | printf("Subtest %d, error %d errno=%d: ", subtest, n, errno);
|
---|
| 376 | errno = err_num;
|
---|
| 377 | perror("");
|
---|
| 378 | if (errct++ > MAX_ERROR) {
|
---|
| 379 | printf("Too many errors; test aborted\n");
|
---|
| 380 | chdir("..");
|
---|
| 381 | system("rm -rf DIR*");
|
---|
| 382 | exit(1);
|
---|
| 383 | }
|
---|
| 384 | errno = 0;
|
---|
| 385 | }
|
---|
| 386 |
|
---|
| 387 | void quit()
|
---|
| 388 | {
|
---|
| 389 | Chdir("..");
|
---|
| 390 | System("rm -rf DIR_24");
|
---|
| 391 |
|
---|
| 392 | if (errct == 0) {
|
---|
| 393 | printf("ok\n");
|
---|
| 394 | exit(0);
|
---|
| 395 | } else {
|
---|
| 396 | printf("%d errors\n", errct);
|
---|
| 397 | exit(1);
|
---|
| 398 | }
|
---|
| 399 | }
|
---|