1 /*
2  * Copyright (c) 2021 Omar Polo <op@omarpolo.com>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include "compat.h"
18 
19 #include <endian.h>
20 #include <inttypes.h>
21 #include <string.h>
22 
23 #include "9pclib.h"
24 #include "kamid.h"
25 #include "log.h"
26 #include "utils.h"
27 
28 uint16_t iota_tag;
29 
30 struct evbuffer *evb;
31 
32 void
33 write_hdr(uint32_t len, uint8_t type, uint16_t tag)
34 {
35 	len += HEADERSIZE;
36 
37 	log_debug("enqueuing a packet; len=%"PRIu32" type=%d[%s] tag=%d",
38 	    len, type, pp_msg_type(type), tag);
39 
40 	len = htole32(len);
41 	/* type is one byte, no endiannes issues */
42 	tag = htole16(tag);
43 		
44 	evbuffer_add(evb, &len, sizeof(len));
45 	evbuffer_add(evb, &type, sizeof(type));
46 	evbuffer_add(evb, &tag, sizeof(tag));
47 }
48 
49 void
50 write_hdr_auto(uint32_t len, uint8_t type)
51 {
52 	if (++iota_tag == NOTAG)
53 		++iota_tag;
54 	write_hdr(len, type, iota_tag);
55 }
56 
57 void
58 write_str(uint16_t len, const char *str)
59 {
60 	uint16_t l = len;
61 
62 	len = htole16(len);
63 	evbuffer_add(evb, &len, sizeof(len));
64 	evbuffer_add(evb, str, l);
65 }
66 
67 void
68 write_str_auto(const char *str)
69 {
70 	write_str(strlen(str), str);
71 }
72 
73 void
74 write_buf(const void *d, uint32_t len)
75 {
76 	write_32(len);
77 	evbuffer_add(evb, d, len);
78 }
79 
80 void
81 write_64(uint64_t x)
82 {
83 	x = htole64(x);
84 	evbuffer_add(evb, &x, sizeof(x));
85 }
86 
87 void
88 write_32(uint32_t fid)
89 {
90 	fid = htole32(fid);
91 	evbuffer_add(evb, &fid, sizeof(fid));
92 }
93 
94 void
95 write_16(uint16_t tag)
96 {
97 	tag = htole16(tag);
98 	evbuffer_add(evb, &tag, sizeof(tag));
99 }
100 
101 void
102 write_8(uint8_t x)
103 {
104 	evbuffer_add(evb, &x, sizeof(x));
105 }
106 
107 
108 
109 void
110 tversion(const char *v, uint32_t msize)
111 {
112 	uint32_t	len;
113 	uint16_t	sl;
114 
115 	sl = strlen(v);
116 
117 	/* msize[4] version[s] */
118 	len = sizeof(msize) + sizeof(sl) + sl;
119 	write_hdr(len, Tversion, NOTAG);
120 	write_32(msize);
121 	write_str(sl, v);
122 }
123 
124 void
125 tattach(uint32_t fid, uint32_t afid, const char *uname, const char *aname)
126 {
127 	uint32_t	len;
128 	uint16_t	ul, al;
129 
130 	ul = strlen(uname);
131 	al = strlen(aname);
132 
133 	/* fid[4] afid[4] uname[s] aname[s] */
134 	len = sizeof(fid) + sizeof(afid) + sizeof(ul) + ul
135 	    + sizeof(al) + al;
136 	write_hdr_auto(len, Tattach);
137 	write_fid(fid);
138 	write_fid(afid);
139 	write_str(ul, uname);
140 	write_str(al, aname);
141 }
142 
143 void
144 tclunk(uint32_t fid)
145 {
146 	uint32_t	len;
147 
148 	/* fid[4] */
149 	len = sizeof(fid);
150 	write_hdr_auto(len, Tclunk);
151 	write_fid(fid);
152 }
153 
154 void
155 tflush(uint16_t oldtag)
156 {
157 	uint32_t	len;
158 
159 	/* oldtag[2] */
160 	len = sizeof(oldtag);
161 	write_hdr_auto(len, Tflush);
162 	write_tag(oldtag);
163 }
164 
165 void
166 twalk(uint32_t fid, uint32_t newfid, const char **wnames, size_t nwname)
167 {
168 	size_t		i;
169 	uint32_t	len;
170 
171 	/* fid[4] newfid[4] nwname[2] nwname*(wname[s]) */
172 	len = sizeof(fid) + sizeof(newfid) + 2;
173 	for (i = 0; i < nwname; ++i)
174 		len += 2 + strlen(wnames[i]);
175 
176 	write_hdr_auto(len, Twalk);
177 	write_fid(fid);
178 	write_fid(newfid);
179 	write_16(nwname);
180 	for (i = 0; i < nwname; ++i)
181 		write_str_auto(wnames[i]);
182 }
183 
184 void
185 topen(uint32_t fid, uint8_t mode)
186 {
187 	uint32_t	len;
188 
189 	/* fid[4] mode[1] */
190 	len = sizeof(fid) + sizeof(mode);
191 	write_hdr_auto(len, Topen);
192 	write_fid(fid);
193 	write_8(mode);
194 }
195 
196 void
197 tcreate(uint32_t fid, const char *name, uint32_t perm, uint8_t mode)
198 {
199 	uint32_t	len;
200 	uint16_t	nl;
201 
202 	/* fid[4] name[s] perm[4] mode[1] */
203 	nl = strlen(name);
204 	len = sizeof(fid) + sizeof(nl) + nl + sizeof(perm) + sizeof(mode);
205 	write_hdr_auto(len, Tcreate);
206 	write_fid(fid);
207 	write_str(nl, name);
208 	write_32(perm);
209 	write_8(mode);
210 }
211 
212 void
213 tread(uint32_t fid, uint64_t off, uint32_t count)
214 {
215 	uint32_t	len;
216 
217 	/* fid[4] off[8] count[4] */
218 	len = sizeof(fid) + sizeof(off) + sizeof(count);
219 	write_hdr_auto(len, Tread);
220 	write_fid(fid);
221 	write_off(off);
222 	write_32(count);
223 }
224 
225 void
226 twrite(uint32_t fid, uint64_t off, const void *data, uint32_t count)
227 {
228 	uint32_t	len;
229 
230 	/* fid[4] off[8] count[4] data[count] */
231 	len = sizeof(fid) + sizeof(off) + sizeof(count) + count;
232 	write_hdr_auto(len, Twrite);
233 	write_fid(fid);
234 	write_off(off);
235 	write_buf(data, count);
236 }
237 
238 void
239 tremove(uint32_t fid)
240 {
241 	/* fid[4] */
242 	write_hdr_auto(sizeof(fid), Tremove);
243 	write_fid(fid);
244 }