Lines Matching refs:ea
30 #include <atalk/ea.h>
109 * Purpose: unpack and verify header file data buffer at ea->ea_data into struct ea
113 * ea (rw) handle to struct ea
121 static int unpack_header(struct ea * __restrict ea)
129 buf = ea->ea_data;
144 ea->ea_count = ntohs(*(uint16_t *)buf);
145 LOG(log_debug, logtype_afpd, "unpack_header: number of EAs: %u", ea->ea_count);
148 if (ea->ea_count == 0)
152 ea->ea_entries = malloc(sizeof(struct ea_entry) * ea->ea_count);
153 if ( ! ea->ea_entries) {
159 buf = ea->ea_data + EA_HEADER_SIZE;
160 while (count < ea->ea_count) {
163 (*(ea->ea_entries))[count].ea_size = ntohl(uint32);
164 (*(ea->ea_entries))[count].ea_name = strdup(buf);
165 if (! (*(ea->ea_entries))[count].ea_name) {
170 (*(ea->ea_entries))[count].ea_namelen = strlen((*(ea->ea_entries))[count].ea_name);
171 buf += (*(ea->ea_entries))[count].ea_namelen + 1;
174 (*(ea->ea_entries))[count].ea_name,
175 (*(ea->ea_entries))[count].ea_size,
176 (*(ea->ea_entries))[count].ea_namelen);
188 * Purpose: pack everything from struct ea into buffer at ea->ea_data
192 * ea (rw) handle to struct ea
198 * adjust ea->ea_count in case an ea entry deletetion is detected
200 static int pack_header(struct ea * __restrict ea)
207 char *buf = ea->ea_data + EA_HEADER_SIZE;
210 ea->filename, ea->ea_count, ea->ea_size);
212 if (ea->ea_count == 0)
216 while(count < ea->ea_count) { /* the names */
218 if ( ! ((*ea->ea_entries)[count].ea_name)) {
223 bufsize += (*(ea->ea_entries))[count].ea_namelen + 1;
229 if (bufsize > ea->ea_size) {
231 if ( ! (buf = realloc(ea->ea_data, bufsize)) ) {
235 ea->ea_data = buf;
237 ea->ea_size = bufsize;
241 memcpy(ea->ea_data + EA_COUNT_OFF, &uint16, 2);
244 buf = ea->ea_data + EA_HEADER_SIZE;
245 while (count < ea->ea_count) {
247 if ( ! ((*ea->ea_entries)[count].ea_name)) {
253 uint32 = htonl((*(ea->ea_entries))[count].ea_size);
258 strcpy(buf, (*(ea->ea_entries))[count].ea_name);
259 buf += (*(ea->ea_entries))[count].ea_namelen + 1;
262 (*(ea->ea_entries))[count].ea_name,
263 (*(ea->ea_entries))[count].ea_size,
264 (*(ea->ea_entries))[count].ea_namelen);
269 ea->ea_count = eacount;
272 ea->filename, ea->ea_count, ea->ea_size);
280 * Purpose: add one EA into ea->ea_entries[]
284 * ea (rw) pointer to struct ea
286 * attrsize (r) size of ea
293 * Grow array ea->ea_entries[]. If ea->ea_entries is still NULL, start allocating.
294 * Otherwise realloc and put entry at the end. Increments ea->ea_count.
296 static int ea_addentry(struct ea * __restrict ea,
306 if (ea->ea_count > 0) {
307 while (count < ea->ea_count) {
308 if (strcmp(attruname, (*ea->ea_entries)[count].ea_name) == 0) {
314 (*(ea->ea_entries))[count].ea_size = attrsize;
325 if (ea->ea_count == 0) {
326 ea->ea_entries = malloc(sizeof(struct ea_entry));
327 if ( ! ea->ea_entries) {
332 tmprealloc = realloc(ea->ea_entries, sizeof(struct ea_entry) * (ea->ea_count + 1));
337 ea->ea_entries = tmprealloc;
341 (*(ea->ea_entries))[ea->ea_count].ea_size = attrsize;
342 (*(ea->ea_entries))[ea->ea_count].ea_name = strdup(attruname);
343 if ( ! (*(ea->ea_entries))[ea->ea_count].ea_name) {
347 (*(ea->ea_entries))[ea->ea_count].ea_namelen = strlen(attruname);
349 ea->ea_count++;
350 return ea->ea_count;
353 if (ea->ea_count == 0 && ea->ea_entries) {
355 free(ea->ea_entries);
356 ea->ea_entries = NULL;
358 ea->ea_count = 0;
370 * ea (rw) ea handle with already allocated storage pointed to
371 * by ea->ea_data
378 * Creates EA header file and initialize ea->ea_data buffer.
388 struct ea * __restrict ea)
393 if ((fd = open(uname, O_RDWR | O_CREAT | O_EXCL, 0666 & ~ea->vol->v_umask)) == -1) {
394 LOG(log_error, logtype_afpd, "ea_create: open race condition with ea header for file: %s", uname);
400 LOG(log_error, logtype_afpd, "ea_create: lock race condition with ea header for file: %s", uname);
406 ptr = ea->ea_data;
413 ea->ea_size = EA_HEADER_SIZE;
414 ea->ea_inited = EA_INITED;
431 * ea (r) struct ea handle
443 static int write_ea(const struct ea * __restrict ea,
452 if ((eaname = ea_path(ea, attruname, 1)) == NULL) {
469 if ((fd = open(eaname, O_RDWR | O_CREAT | O_EXCL, 0666 & ~ea->vol->v_umask)) == -1) {
496 * Purpose: delete one EA from ea->ea_entries[]
500 * ea (rw) pointer to struct ea
507 * Remove entry from ea->ea_entries[]. Decrement ea->ea_count.
511 static int ea_delentry(struct ea * __restrict ea, const char * __restrict attruname)
516 if (ea->ea_count == 0) {
521 while (count < ea->ea_count) {
523 if (strcmp(attruname, (*ea->ea_entries)[count].ea_name) == 0) {
524 free((*ea->ea_entries)[count].ea_name);
525 (*ea->ea_entries)[count].ea_name = NULL;
528 attruname, count + 1, ea->ea_count);
545 * ea (r) struct ea handle
550 static int delete_ea_file(const struct ea * __restrict ea, const char *eaname)
556 if ((eafile = ea_path(ea, eaname, 1)) == NULL) {
581 * Purpose: return name of ea header filename
585 * ea (r) ea handle
598 char *ea_path(const struct ea * __restrict ea, const char * __restrict eaname, int macname)
604 adname = ea->vol->ad_path(ea->filename, (ea->ea_flags & EA_DIR) ? ADFLAGS_DIR : 0);
613 if ((eaname = mtoupath(ea->vol, eaname)) == NULL)
634 * ea (w) pointer to a struct ea that we fill
642 * opens header file and stores fd in ea->ea_fd. Size of file is put into ea->ea_size.
643 * number of EAs is stored in ea->ea_count. flags are remembered in ea->ea_flags.
645 * When you're done with struct ea you must call ea_close on it.
650 struct ea * __restrict ea)
663 memset(ea, 0, sizeof(struct ea));
665 ea->vol = vol; /* ea_close needs it */
666 ea->ea_flags = eaflags;
667 ea->dirfd = -1; /* no *at (cf openat) semantics by default */
671 ea->ea_flags |= EA_DIR;
673 if ( ! (ea->filename = strdup(uname))) {
678 eaname = ea_path(ea, NULL, 0);
696 ea->ea_data = malloc(EA_HEADER_SIZE);
697 if (! ea->ea_data) {
704 ea->ea_fd = create_ea_header(eaname, ea);
705 if (ea->ea_fd == -1) {
726 ea->ea_size = st.st_size;
727 ea->ea_data = malloc(st.st_size);
728 if (! ea->ea_data) {
735 if ((ea->ea_fd = open(eaname, (ea->ea_flags & EA_RDWR) ? O_RDWR : O_RDONLY)) == -1) {
742 if (ea->ea_flags & EA_RDONLY) {
744 if ((read_lock(ea->ea_fd, 0, SEEK_SET, 0)) != 0) {
751 if ((write_lock(ea->ea_fd, 0, SEEK_SET, 0)) != 0) {
759 if (read(ea->ea_fd, ea->ea_data, ea->ea_size) != (ssize_t)ea->ea_size) {
765 if ((unpack_header(ea)) != 0) {
774 ea->ea_inited = EA_INITED;
780 if (ea->ea_data) {
781 free(ea->ea_data);
782 ea->ea_data = NULL;
784 if (ea->ea_fd) {
785 close(ea->ea_fd);
786 ea->ea_fd = -1;
808 * ea (w) pointer to a struct ea that we fill
816 * opens header file and stores fd in ea->ea_fd. Size of file is put into ea->ea_size.
817 * number of EAs is stored in ea->ea_count. flags are remembered in ea->ea_flags.
819 * When you're done with struct ea you must call ea_close on it.
825 struct ea * __restrict ea)
837 ret = ea_open(vol, uname, eaflags, ea);
838 ea->dirfd = dirfd;
859 * Purpose: flushes and closes an ea handle
863 * ea (rw) pointer to ea handle
869 * Flushes and then closes and frees all resouces held by ea handle.
870 * Pack data in ea into ea_data, then write ea_data to disk
872 int ea_close(struct ea * __restrict ea)
879 LOG(log_debug, logtype_afpd, "ea_close('%s')", ea->filename);
881 if (ea->ea_inited != EA_INITED) {
882 LOG(log_warning, logtype_afpd, "ea_close('%s'): non initialized ea", ea->filename);
887 if (ea->ea_flags & EA_RDWR) {
888 if ((pack_header(ea)) != 0) {
892 if (ea->ea_count == 0) {
894 eaname = ea_path(ea, NULL, 0);
895 if ((lstatat(ea->dirfd, eaname, &st)) == 0) {
896 if ((netatalk_unlinkat(ea->dirfd, eaname)) != 0) {
911 } else { /* ea->ea_count > 0 */
912 if ((lseek(ea->ea_fd, 0, SEEK_SET)) == -1) {
918 if ((ftruncate(ea->ea_fd, 0)) == -1) {
924 if (write(ea->ea_fd, ea->ea_data, ea->ea_size) != (ssize_t)ea->ea_size) {
934 while(count < ea->ea_count) {
935 if ( (*ea->ea_entries)[count].ea_name ) {
936 free((*ea->ea_entries)[count].ea_name);
937 (*ea->ea_entries)[count].ea_name = NULL;
941 ea->ea_count = 0;
943 if (ea->filename) {
944 free(ea->filename);
945 ea->filename = NULL;
948 if (ea->ea_entries) {
949 free(ea->ea_entries);
950 ea->ea_entries = NULL;
953 if (ea->ea_data) {
954 free(ea->ea_data);
955 ea->ea_data = NULL;
957 if (ea->ea_fd != -1) {
958 close(ea->ea_fd); /* also releases the fcntl lock */
959 ea->ea_fd = -1;
996 struct ea ea;
1000 if ((ea_open(vol, uname, EA_RDONLY, &ea)) != 0) {
1009 while (count < ea.ea_count) {
1010 if (strcmp(attruname, (*ea.ea_entries)[count].ea_name) == 0) {
1011 uint32 = htonl((*ea.ea_entries)[count].ea_size);
1017 attruname, (*ea.ea_entries)[count].ea_size);
1023 if ((ea_close(&ea)) != 0) {
1024 LOG(log_error, logtype_afpd, "get_easize: error closing ea handle for file: %s", uname);
1058 struct ea ea;
1063 if ((ea_open(vol, uname, EA_RDONLY, &ea)) != 0) {
1071 while (count < ea.ea_count) {
1072 if (strcmp(attruname, (*ea.ea_entries)[count].ea_name) == 0) {
1073 if ( (eafile = ea_path(&ea, attruname, 1)) == NULL) {
1088 toread = (maxreply < (*ea.ea_entries)[count].ea_size) ? maxreply : (*ea.ea_entries)[count].ea_size;
1112 if ((ea_close(&ea)) != 0) {
1113 LOG(log_error, logtype_afpd, "get_eacontent('%s'): error closing ea handle", uname);
1146 struct ea ea;
1150 if ((ea_open(vol, uname, EA_RDONLY, &ea)) != 0) {
1159 while (count < ea.ea_count) {
1163 (*ea.ea_entries)[count].ea_name,
1164 (*ea.ea_entries)[count].ea_namelen,
1176 uname, (*ea.ea_entries)[count].ea_name);
1193 if ((ea_close(&ea)) != 0) {
1194 LOG(log_error, logtype_afpd, "list_eas: error closing ea handle for file: %s", uname);
1225 struct ea ea;
1229 if ((ea_open(vol, uname, EA_CREATE | EA_RDWR, &ea)) != 0) {
1234 if ((ea_addentry(&ea, attruname, attrsize, oflag)) == -1) {
1240 if ((write_ea(&ea, attruname, ibuf, attrsize)) != 0) {
1247 if ((ea_close(&ea)) != 0) {
1277 struct ea ea;
1281 if ((ea_open(vol, uname, EA_RDWR, &ea)) != 0) {
1286 if ((ea_delentry(&ea, attruname)) == -1) {
1292 if ((delete_ea_file(&ea, attruname)) != 0) {
1299 if ((ea_close(&ea)) != 0) {
1317 struct ea ea;
1322 if ((ea_openat(vol, dirfd, file, EA_RDWR, &ea)) != 0) {
1339 while (count < ea.ea_count) {
1340 if ((delete_ea_file(&ea, (*ea.ea_entries)[count].ea_name)) != 0) {
1344 free((*ea.ea_entries)[count].ea_name);
1345 (*ea.ea_entries)[count].ea_name = NULL;
1350 if ((ea_close(&ea)) != 0) {
1351 LOG(log_error, logtype_afpd, "ea_deletefile('%s'): error closing ea handle", file);
1375 struct ea srcea;
1376 struct ea dstea;
1473 struct ea srcea;
1474 struct ea dstea;
1558 struct ea ea;
1562 if ((ea_open(vol, path, EA_RDWR, &ea)) != 0) {
1572 if ((lchown(ea_path(&ea, NULL, 0), uid, gid)) != 0) {
1584 while (count < ea.ea_count) {
1585 if ((eaname = ea_path(&ea, (*ea.ea_entries)[count].ea_name, 1)) == NULL) {
1606 if ((ea_close(&ea)) != 0) {
1607 LOG(log_error, logtype_afpd, "ea_chown('%s'): error closing ea handle", path);
1620 struct ea ea;
1624 if ((ea_open(vol, name, EA_RDWR, &ea)) != 0) {
1633 if ((setfilmode(ea_path(&ea, NULL, 0), ea_header_mode(mode), NULL, vol->v_umask)) != 0) {
1634 LOG(log_error, logtype_afpd, "ea_chmod_file('%s'): %s", ea_path(&ea, NULL, 0), strerror(errno));
1647 while (count < ea.ea_count) {
1648 if ((eaname = ea_path(&ea, (*ea.ea_entries)[count].ea_name, 1)) == NULL) {
1670 if ((ea_close(&ea)) != 0) {
1671 LOG(log_error, logtype_afpd, "ea_chmod_file('%s'): error closing ea handle", name);
1686 struct ea ea;
1697 if ((ea_open(vol, name, EA_RDWR, &ea)) != 0) {
1709 if ((setfilmode(ea_path(&ea, NULL, 0), ea_header_mode(mode), NULL, vol->v_umask)) != 0) {
1710 LOG(log_error, logtype_afpd, "ea_chmod_dir('%s'): %s", ea_path(&ea, NULL, 0), strerror(errno));
1723 while (count < ea.ea_count) {
1724 eaname = (*ea.ea_entries)[count].ea_name;
1735 if ((eaname = ea_path(&ea, eaname, 1)) == NULL) {
1762 if ((ea_close(&ea)) != 0) {
1763 LOG(log_error, logtype_afpd, "ea_chmod_dir('%s'): error closing ea handle", name);