1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
|
/******************************************************/
/* tpax: a topological pax implementation */
/* Copyright (C) 2020 Z. Gilboa */
/* Released under GPLv2 and GPLv3; see COPYING.TPAX. */
/******************************************************/
#ifndef TPAX_DRIVER_IMPL_H
#define TPAX_DRIVER_IMPL_H
#include <stdint.h>
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <tpax/tpax.h>
#include <tpax/tpax_specs.h>
#include "tpax_dprintf_impl.h"
#include "argv/argv.h"
#define TPAX_OPTV_ELEMENTS 64
#define TPAX_DRIVER_EXEC_MODE_WRITE_COPY \
(TPAX_DRIVER_EXEC_MODE_WRITE | \
TPAX_DRIVER_EXEC_MODE_COPY)
extern const struct argv_option tpax_default_options[];
enum app_tags {
TAG_HELP,
TAG_VERSION,
TAG_LIST,
TAG_READ,
TAG_WRITE,
TAG_COPY,
TAG_FORMAT,
TAG_BLKSIZE,
TAG_RECURSE,
TAG_NORECURSE,
TAG_STRICT_PATH,
TAG_PURE_PATH,
};
struct tpax_driver_ctx_impl {
struct tpax_common_ctx cctx;
struct tpax_driver_ctx ctx;
struct tpax_fd_ctx fdctx;
const struct tpax_unit_ctx * euctx;
const char * eunit;
struct tpax_error_info ** errinfp;
struct tpax_error_info ** erricap;
struct tpax_error_info * erriptr[64];
struct tpax_error_info erribuf[64];
void * bufaddr;
size_t bufsize;
off_t cpos;
};
struct tpax_unit_ctx_impl {
const char * path;
struct tpax_unit_ctx uctx;
struct stat st;
off_t hpos;
off_t dpos;
const char * link;
char linkbuf[1024];
union {
struct tpax_ustar_header uhdr;
struct tpax_cpio_header chdr;
} hdrbufs;
};
static inline struct tpax_driver_ctx_impl * tpax_get_driver_ictx(
const struct tpax_driver_ctx * dctx)
{
uintptr_t addr;
if (dctx) {
addr = (uintptr_t)dctx - offsetof(struct tpax_driver_ctx_impl,ctx);
return (struct tpax_driver_ctx_impl *)addr;
}
return 0;
}
static inline struct tpax_unit_ctx_impl * tpax_get_unit_ictx(
const struct tpax_unit_ctx * uctx)
{
struct tpax_unit_ctx_impl * ictx;
uintptr_t addr;
addr = (uintptr_t)uctx - offsetof(struct tpax_unit_ctx_impl,uctx);
ictx = (struct tpax_unit_ctx_impl *)addr;
return ictx;
}
static inline void * tpax_get_driver_anon_map_addr(
const struct tpax_driver_ctx * dctx,
size_t * size)
{
struct tpax_driver_ctx_impl * ictx = tpax_get_driver_ictx(dctx);
*size = ictx->bufsize;
return ictx->bufaddr;
}
static inline void tpax_driver_set_ectx(
const struct tpax_driver_ctx * dctx,
const struct tpax_unit_ctx * uctx,
const char * unit)
{
struct tpax_driver_ctx_impl * ictx;
ictx = tpax_get_driver_ictx(dctx);
ictx->euctx = uctx;
ictx->eunit = unit;
}
static inline int tpax_driver_fdin(const struct tpax_driver_ctx * dctx)
{
struct tpax_fd_ctx fdctx;
tpax_get_driver_fdctx(dctx,&fdctx);
return fdctx.fdin;
}
static inline int tpax_driver_fdout(const struct tpax_driver_ctx * dctx)
{
struct tpax_fd_ctx fdctx;
tpax_get_driver_fdctx(dctx,&fdctx);
return fdctx.fdout;
}
static inline int tpax_driver_fderr(const struct tpax_driver_ctx * dctx)
{
struct tpax_fd_ctx fdctx;
tpax_get_driver_fdctx(dctx,&fdctx);
return fdctx.fderr;
}
static inline int tpax_driver_fdlog(const struct tpax_driver_ctx * dctx)
{
struct tpax_fd_ctx fdctx;
tpax_get_driver_fdctx(dctx,&fdctx);
return fdctx.fdlog;
}
static inline int tpax_driver_fdcwd(const struct tpax_driver_ctx * dctx)
{
struct tpax_fd_ctx fdctx;
tpax_get_driver_fdctx(dctx,&fdctx);
return fdctx.fdcwd;
}
static inline int tpax_driver_fddst(const struct tpax_driver_ctx * dctx)
{
struct tpax_fd_ctx fdctx;
tpax_get_driver_fdctx(dctx,&fdctx);
return fdctx.fddst;
}
static inline off_t tpax_get_driver_cpos(const struct tpax_driver_ctx * dctx)
{
struct tpax_driver_ctx_impl * ictx;
ictx = tpax_get_driver_ictx(dctx);
return ictx->cpos;
}
static inline void tpax_set_driver_cpos(const struct tpax_driver_ctx * dctx, off_t cpos)
{
struct tpax_driver_ctx_impl * ictx;
ictx = tpax_get_driver_ictx(dctx);
ictx->cpos = cpos;
}
static inline off_t tpax_get_unit_hpos(const struct tpax_unit_ctx * uctx)
{
struct tpax_unit_ctx_impl * ictx;
ictx = tpax_get_unit_ictx(uctx);
return ictx->hpos;
}
static inline void tpax_set_unit_hpos(const struct tpax_unit_ctx * uctx, off_t hpos)
{
struct tpax_unit_ctx_impl * ictx;
ictx = tpax_get_unit_ictx(uctx);
ictx->hpos = hpos;
}
static inline off_t tpax_get_unit_dpos(const struct tpax_unit_ctx * uctx)
{
struct tpax_unit_ctx_impl * ictx;
ictx = tpax_get_unit_ictx(uctx);
return ictx->dpos;
}
static inline void tpax_set_unit_dpos(const struct tpax_unit_ctx * uctx, off_t dpos)
{
struct tpax_unit_ctx_impl * ictx;
ictx = tpax_get_unit_ictx(uctx);
ictx->dpos = dpos;
}
static inline ssize_t tpax_get_archive_block_size(const struct tpax_driver_ctx * dctx)
{
if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_PAX)
return TPAX_PAX_BLOCK_SIZE;
else if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_CPIO)
return TPAX_CPIO_BLOCK_SIZE;
else if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_USTAR)
return TPAX_USTAR_BLOCK_SIZE;
else if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_RUSTAR)
return TPAX_USTAR_BLOCK_SIZE;
else
return 0;
}
#endif
|
