1 /*
2 * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10 /* This must be the first #include file */
11 #include "async_local.h"
12
13 #include <openssl/err.h>
14
ASYNC_WAIT_CTX_new(void)15 ASYNC_WAIT_CTX *ASYNC_WAIT_CTX_new(void)
16 {
17 return OPENSSL_zalloc(sizeof(ASYNC_WAIT_CTX));
18 }
19
ASYNC_WAIT_CTX_free(ASYNC_WAIT_CTX * ctx)20 void ASYNC_WAIT_CTX_free(ASYNC_WAIT_CTX *ctx)
21 {
22 struct fd_lookup_st *curr;
23 struct fd_lookup_st *next;
24
25 if (ctx == NULL)
26 return;
27
28 curr = ctx->fds;
29 while (curr != NULL) {
30 if (!curr->del) {
31 /* Only try and cleanup if it hasn't been marked deleted */
32 if (curr->cleanup != NULL)
33 curr->cleanup(ctx, curr->key, curr->fd, curr->custom_data);
34 }
35 /* Always free the fd_lookup_st */
36 next = curr->next;
37 OPENSSL_free(curr);
38 curr = next;
39 }
40
41 OPENSSL_free(ctx);
42 }
ASYNC_WAIT_CTX_set_wait_fd(ASYNC_WAIT_CTX * ctx,const void * key,OSSL_ASYNC_FD fd,void * custom_data,void (* cleanup)(ASYNC_WAIT_CTX *,const void *,OSSL_ASYNC_FD,void *))43 int ASYNC_WAIT_CTX_set_wait_fd(ASYNC_WAIT_CTX *ctx, const void *key,
44 OSSL_ASYNC_FD fd, void *custom_data,
45 void (*cleanup)(ASYNC_WAIT_CTX *, const void *,
46 OSSL_ASYNC_FD, void *))
47 {
48 struct fd_lookup_st *fdlookup;
49
50 if ((fdlookup = OPENSSL_zalloc(sizeof(*fdlookup))) == NULL)
51 return 0;
52
53 fdlookup->key = key;
54 fdlookup->fd = fd;
55 fdlookup->custom_data = custom_data;
56 fdlookup->cleanup = cleanup;
57 fdlookup->add = 1;
58 fdlookup->next = ctx->fds;
59 ctx->fds = fdlookup;
60 ctx->numadd++;
61 return 1;
62 }
63
ASYNC_WAIT_CTX_get_fd(ASYNC_WAIT_CTX * ctx,const void * key,OSSL_ASYNC_FD * fd,void ** custom_data)64 int ASYNC_WAIT_CTX_get_fd(ASYNC_WAIT_CTX *ctx, const void *key,
65 OSSL_ASYNC_FD *fd, void **custom_data)
66 {
67 struct fd_lookup_st *curr;
68
69 curr = ctx->fds;
70 while (curr != NULL) {
71 if (curr->del) {
72 /* This one has been marked deleted so do nothing */
73 curr = curr->next;
74 continue;
75 }
76 if (curr->key == key) {
77 *fd = curr->fd;
78 *custom_data = curr->custom_data;
79 return 1;
80 }
81 curr = curr->next;
82 }
83 return 0;
84 }
85
ASYNC_WAIT_CTX_get_all_fds(ASYNC_WAIT_CTX * ctx,OSSL_ASYNC_FD * fd,size_t * numfds)86 int ASYNC_WAIT_CTX_get_all_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *fd,
87 size_t *numfds)
88 {
89 struct fd_lookup_st *curr;
90
91 curr = ctx->fds;
92 *numfds = 0;
93 while (curr != NULL) {
94 if (curr->del) {
95 /* This one has been marked deleted so do nothing */
96 curr = curr->next;
97 continue;
98 }
99 if (fd != NULL) {
100 *fd = curr->fd;
101 fd++;
102 }
103 (*numfds)++;
104 curr = curr->next;
105 }
106 return 1;
107 }
108
ASYNC_WAIT_CTX_get_changed_fds(ASYNC_WAIT_CTX * ctx,OSSL_ASYNC_FD * addfd,size_t * numaddfds,OSSL_ASYNC_FD * delfd,size_t * numdelfds)109 int ASYNC_WAIT_CTX_get_changed_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *addfd,
110 size_t *numaddfds, OSSL_ASYNC_FD *delfd,
111 size_t *numdelfds)
112 {
113 struct fd_lookup_st *curr;
114
115 *numaddfds = ctx->numadd;
116 *numdelfds = ctx->numdel;
117 if (addfd == NULL && delfd == NULL)
118 return 1;
119
120 curr = ctx->fds;
121
122 while (curr != NULL) {
123 /* We ignore fds that have been marked as both added and deleted */
124 if (curr->del && !curr->add && (delfd != NULL)) {
125 *delfd = curr->fd;
126 delfd++;
127 }
128 if (curr->add && !curr->del && (addfd != NULL)) {
129 *addfd = curr->fd;
130 addfd++;
131 }
132 curr = curr->next;
133 }
134
135 return 1;
136 }
137
ASYNC_WAIT_CTX_clear_fd(ASYNC_WAIT_CTX * ctx,const void * key)138 int ASYNC_WAIT_CTX_clear_fd(ASYNC_WAIT_CTX *ctx, const void *key)
139 {
140 struct fd_lookup_st *curr, *prev;
141
142 curr = ctx->fds;
143 prev = NULL;
144 while (curr != NULL) {
145 if (curr->del == 1) {
146 /* This one has been marked deleted already so do nothing */
147 prev = curr;
148 curr = curr->next;
149 continue;
150 }
151 if (curr->key == key) {
152 /* If fd has just been added, remove it from the list */
153 if (curr->add == 1) {
154 if (ctx->fds == curr) {
155 ctx->fds = curr->next;
156 } else {
157 prev->next = curr->next;
158 }
159
160 /* It is responsibility of the caller to cleanup before calling
161 * ASYNC_WAIT_CTX_clear_fd
162 */
163 OPENSSL_free(curr);
164 ctx->numadd--;
165 return 1;
166 }
167
168 /*
169 * Mark it as deleted. We don't call cleanup if explicitly asked
170 * to clear an fd. We assume the caller is going to do that (if
171 * appropriate).
172 */
173 curr->del = 1;
174 ctx->numdel++;
175 return 1;
176 }
177 prev = curr;
178 curr = curr->next;
179 }
180 return 0;
181 }
182
ASYNC_WAIT_CTX_set_callback(ASYNC_WAIT_CTX * ctx,ASYNC_callback_fn callback,void * callback_arg)183 int ASYNC_WAIT_CTX_set_callback(ASYNC_WAIT_CTX *ctx,
184 ASYNC_callback_fn callback,
185 void *callback_arg)
186 {
187 if (ctx == NULL)
188 return 0;
189
190 ctx->callback = callback;
191 ctx->callback_arg = callback_arg;
192 return 1;
193 }
194
ASYNC_WAIT_CTX_get_callback(ASYNC_WAIT_CTX * ctx,ASYNC_callback_fn * callback,void ** callback_arg)195 int ASYNC_WAIT_CTX_get_callback(ASYNC_WAIT_CTX *ctx,
196 ASYNC_callback_fn *callback,
197 void **callback_arg)
198 {
199 if (ctx->callback == NULL)
200 return 0;
201
202 *callback = ctx->callback;
203 *callback_arg = ctx->callback_arg;
204 return 1;
205 }
206
ASYNC_WAIT_CTX_set_status(ASYNC_WAIT_CTX * ctx,int status)207 int ASYNC_WAIT_CTX_set_status(ASYNC_WAIT_CTX *ctx, int status)
208 {
209 ctx->status = status;
210 return 1;
211 }
212
ASYNC_WAIT_CTX_get_status(ASYNC_WAIT_CTX * ctx)213 int ASYNC_WAIT_CTX_get_status(ASYNC_WAIT_CTX *ctx)
214 {
215 return ctx->status;
216 }
217
async_wait_ctx_reset_counts(ASYNC_WAIT_CTX * ctx)218 void async_wait_ctx_reset_counts(ASYNC_WAIT_CTX *ctx)
219 {
220 struct fd_lookup_st *curr, *prev = NULL;
221
222 ctx->numadd = 0;
223 ctx->numdel = 0;
224
225 curr = ctx->fds;
226
227 while (curr != NULL) {
228 if (curr->del) {
229 if (prev == NULL)
230 ctx->fds = curr->next;
231 else
232 prev->next = curr->next;
233 OPENSSL_free(curr);
234 if (prev == NULL)
235 curr = ctx->fds;
236 else
237 curr = prev->next;
238 continue;
239 }
240 if (curr->add) {
241 curr->add = 0;
242 }
243 prev = curr;
244 curr = curr->next;
245 }
246 }
247
