Bug Summary

File:lib/keys.c
Warning:line 273, column 7
Value stored to 'res' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-redhat-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name keys.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/builds/gsasl/shishi/lib -resource-dir /usr/lib64/clang/14.0.0 -D HAVE_CONFIG_H -I . -I .. -I ./gl -I ./gl -D LOCALEDIR="/usr/local/share/locale" -D SYSTEMCFGFILE="/usr/local/etc/shishi/shishi.conf" -D SKELCFGFILE="/usr/local/etc/shishi/shishi.skel" -D HOSTKEYSFILE="/usr/local/etc/shishi/shishi.keys" -D PIC -internal-isystem /usr/lib64/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/builds/gsasl/shishi/lib -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /builds/gsasl/shishi/clang-analyzer/2022-08-08-065803-50050-1 -x c keys.c
1/* keys.c --- Functions for managing keys sets, and keys stored in files.
2 * Copyright (C) 2002-2022 Simon Josefsson
3 *
4 * This file is part of Shishi.
5 *
6 * Shishi is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * Shishi is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with Shishi; if not, see http://www.gnu.org/licenses or write
18 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
19 * Floor, Boston, MA 02110-1301, USA
20 *
21 */
22
23#include "internal.h"
24
25struct Shishi_keys
26{
27 Shishi *handle;
28 Shishi_key **keys;
29 int nkeys;
30};
31
32/**
33 * shishi_keys:
34 * @handle: shishi handle as allocated by shishi_init().
35 * @keys: output pointer to newly allocated keys handle.
36 *
37 * Get a new key set handle.
38 *
39 * Return value: Returns %SHISHI_OK iff successful.
40 **/
41int
42shishi_keys (Shishi * handle, Shishi_keys ** keys)
43{
44 *keys = xmalloc (sizeof (**keys));
45
46 (*keys)->handle = handle;
47 (*keys)->keys = NULL((void*)0);
48 (*keys)->nkeys = 0;
49
50 return SHISHI_OK;
51}
52
53/**
54 * shishi_keys_done:
55 * @keys: key set handle as allocated by shishi_keys().
56 *
57 * Deallocates all resources associated with key set. The key set
58 * handle must not be used in calls to other shishi_keys_*() functions
59 * after this.
60 **/
61void
62shishi_keys_done (Shishi_keys ** keys)
63{
64 size_t i;
65
66 if (!keys || !*keys)
67 return;
68
69 if ((*keys)->nkeys > 0)
70 for (i = (*keys)->nkeys; i > 0; i--)
71 shishi_key_done ((*keys)->keys[i - 1]);
72
73 free ((*keys)->keys);
74 free (*keys);
75
76 *keys = NULL((void*)0);
77
78 return;
79}
80
81/**
82 * shishi_keys_size:
83 * @keys: key set handle as allocated by shishi_keys().
84 *
85 * Get size of key set.
86 *
87 * Return value: Returns number of keys stored in key set.
88 **/
89int
90shishi_keys_size (Shishi_keys * keys)
91{
92 return keys->nkeys;
93}
94
95/**
96 * shishi_keys_nth:
97 * @keys: key set handle as allocated by shishi_keys().
98 * @keyno: integer indicating requested key in key set.
99 *
100 * Get the n:th ticket in key set.
101 *
102 * Return value: Returns a key handle to the keyno:th key in the key
103 * set, or NULL if @keys is invalid or @keyno is out of bounds. The
104 * first key is @keyno 0, the second key @keyno 1, and so on.
105 **/
106const Shishi_key *
107shishi_keys_nth (Shishi_keys * keys, int keyno)
108{
109 if (keys == NULL((void*)0) || keyno >= keys->nkeys)
110 return NULL((void*)0);
111
112 return keys->keys[keyno];
113}
114
115/**
116 * shishi_keys_remove:
117 * @keys: key set handle as allocated by shishi_keys().
118 * @keyno: key number of key in the set to remove. The first
119 * key is key number 0.
120 *
121 * Remove a key, indexed by @keyno, in given key set.
122 **/
123void
124shishi_keys_remove (Shishi_keys * keys, int keyno)
125{
126 shishi_key_done (keys->keys[keyno]);
127
128 if (keyno < keys->nkeys)
129 memmove (&keys->keys[keyno], &keys->keys[keyno + 1],
130 sizeof (*keys->keys) * (keys->nkeys - keyno - 1));
131
132 --keys->nkeys;
133
134 keys->keys = xrealloc (keys->keys, sizeof (*keys->keys) * keys->nkeys);
135}
136
137/**
138 * shishi_keys_add:
139 * @keys: key set handle as allocated by shishi_keys().
140 * @key: key to be added to key set.
141 *
142 * Add a key to the key set. A deep copy of the key is stored, so
143 * changing @key, or deallocating it, will not modify the value stored
144 * in the key set.
145 *
146 * Return value: Returns %SHISHI_OK iff successful.
147 **/
148int
149shishi_keys_add (Shishi_keys * keys, Shishi_key * key)
150{
151 int rc;
152
153 if (!key)
154 return SHISHI_INVALID_KEY;
155
156 keys->nkeys++;
157
158 keys->keys = xrealloc (keys->keys, sizeof (*keys->keys) * keys->nkeys);
159
160 rc = shishi_key (keys->handle, &(keys->keys[keys->nkeys - 1]));
161 if (rc != SHISHI_OK)
162 return rc;
163
164 shishi_key_copy (keys->keys[keys->nkeys - 1], key);
165
166 return SHISHI_OK;
167}
168
169/**
170 * shishi_keys_print:
171 * @keys: key set to print.
172 * @fh: file handle, open for writing, to print keys to.
173 *
174 * Print all keys in set using shishi_key_print.
175 *
176 * Returns: Returns %SHISHI_OK on success.
177 **/
178int
179shishi_keys_print (Shishi_keys * keys, FILE * fh)
180{
181 int rc;
182 int i;
183
184 for (i = 0; i < keys->nkeys; i++)
185 {
186 rc = shishi_key_print (keys->handle, fh, shishi_keys_nth (keys, i));
187 if (rc != SHISHI_OK)
188 return rc;
189
190 fprintf (fh, "\n");
191 }
192
193 return SHISHI_OK;
194}
195
196/**
197 * shishi_keys_to_file:
198 * @handle: shishi handle as allocated by shishi_init().
199 * @filename: filename to append key to.
200 * @keys: set of keys to print.
201 *
202 * Print an ASCII representation of a key structure to a file, for
203 * each key in the key set. The file is appended to if it exists.
204 * See shishi_key_print() for the format of the output.
205 *
206 * Return value: Returns %SHISHI_OK iff successful.
207 **/
208int
209shishi_keys_to_file (Shishi * handle,
210 const char *filename, Shishi_keys * keys)
211{
212 FILE *fh;
213 int res;
214
215 if (VERBOSE (handle)(handle->verbose & ~((1<<2) | (1<<3) | (1<<
1) | (1<<4)))
)
216 printf (_("Writing KEYS to %s...\n")dcgettext ("shishi", "Writing KEYS to %s...\n", 5), filename);
217
218 fh = fopen (filename, "a");
219 if (fh == NULL((void*)0))
220 return SHISHI_FOPEN_ERROR;
221
222 res = shishi_keys_print (keys, fh);
223 if (res != SHISHI_OK)
224 return res;
225
226 res = fclose (fh);
227 if (res != 0)
228 return SHISHI_IO_ERROR;
229
230 if (VERBOSE (handle)(handle->verbose & ~((1<<2) | (1<<3) | (1<<
1) | (1<<4)))
)
231 printf (_("Writing KEYS to %s...done\n")dcgettext ("shishi", "Writing KEYS to %s...done\n", 5), filename);
232
233 return SHISHI_OK;
234}
235
236/**
237 * shishi_keys_from_file:
238 * @keys: key set handle as allocated by shishi_keys().
239 * @filename: filename to read keys from.
240 *
241 * Read zero or more keys from file @filename and append them to the
242 * keyset @keys. See shishi_key_print() for the format of the input.
243 *
244 * Return value: Returns %SHISHI_OK iff successful.
245 *
246 * Since: 0.0.42
247 **/
248int
249shishi_keys_from_file (Shishi_keys * keys, const char *filename)
250{
251 FILE *fh;
252 int res;
253
254 fh = fopen (filename, "r");
255 if (fh == NULL((void*)0))
256 return SHISHI_FOPEN_ERROR;
257
258 res = SHISHI_OK;
259 while (!feof (fh))
260 {
261 Shishi_key *key = NULL((void*)0);
262
263 res = shishi_key_parse (keys->handle, fh, &key);
264 if (res != SHISHI_OK || key == NULL((void*)0))
265 break;
266
267 if (VERBOSENOISE (keys->handle)(keys->handle->verbose & (1<<1)))
268 {
269 printf ("Read key:\n");
270 shishi_key_print (keys->handle, stdoutstdout, key);
271 }
272
273 res = shishi_keys_add (keys, key);
Value stored to 'res' is never read
274
275 shishi_key_done (key);
276 key = NULL((void*)0);
277 }
278
279 res = fclose (fh);
280 if (res != 0)
281 return SHISHI_IO_ERROR;
282
283 return SHISHI_OK;
284}
285
286/**
287 * shishi_keys_for_serverrealm_in_file
288 * @handle: Shishi library handle create by shishi_init().
289 * @filename: file to read keys from.
290 * @server: server name to get key for.
291 * @realm: realm of server to get key for.
292 *
293 * Get keys that match specified @server and @realm from the key set
294 * file @filename.
295 *
296 * Return value: Returns the key for specific server and realm, read
297 * from the indicated file, or NULL if no key could be found or an
298 * error encountered.
299 **/
300Shishi_key *
301shishi_keys_for_serverrealm_in_file (Shishi * handle,
302 const char *filename,
303 const char *server, const char *realm)
304{
305 Shishi_key *key = NULL((void*)0);
306 FILE *fh;
307 int res;
308
309 fh = fopen (filename, "r");
310 if (fh == NULL((void*)0))
311 return NULL((void*)0);
312
313 res = SHISHI_OK;
314 while (!feof (fh))
315 {
316 res = shishi_key_parse (handle, fh, &key);
317 if (res != SHISHI_OK || key == NULL((void*)0))
318 break;
319
320 if (VERBOSENOISE (handle)(handle->verbose & (1<<1)))
321 {
322 printf ("Read key:\n");
323 shishi_key_print (handle, stdoutstdout, key);
324 }
325
326 if ((!server ||
327 (shishi_key_principal (key) &&
328 strcmp (server, shishi_key_principal (key)) == 0)) &&
329 (!realm ||
330 (shishi_key_realm (key) &&
331 strcmp (realm, shishi_key_realm (key)) == 0)))
332 break;
333
334 shishi_key_done (key);
335 key = NULL((void*)0);
336 }
337
338 res = fclose (fh);
339 if (res != 0)
340 return NULL((void*)0);
341
342 return key;
343}
344
345/**
346 * shishi_keys_for_server_in_file
347 * @handle: Shishi library handle create by shishi_init().
348 * @filename: file to read keys from.
349 * @server: server name to get key for.
350 *
351 * Get key for specified @server from @filename.
352 *
353 * Return value: Returns the key for specific server, read from the
354 * indicated file, or NULL if no key could be found or an error
355 * encountered.
356 **/
357Shishi_key *
358shishi_keys_for_server_in_file (Shishi * handle,
359 const char *filename, const char *server)
360{
361 return shishi_keys_for_serverrealm_in_file (handle, filename, server, NULL((void*)0));
362}
363
364/**
365 * shishi_keys_for_localservicerealm_in_file:
366 * @handle: Shishi library handle create by shishi_init().
367 * @filename: file to read keys from.
368 * @service: service to get key for.
369 * @realm: realm of server to get key for, or NULL for default realm.
370 *
371 * Get key for specified @service and @realm from @filename.
372 *
373 * Return value: Returns the key for the server
374 * "SERVICE/HOSTNAME@REALM" (where HOSTNAME is the current system's
375 * hostname), read from the default host keys file (see
376 * shishi_hostkeys_default_file()), or NULL if no key could be found
377 * or an error encountered.
378 **/
379Shishi_key *
380shishi_keys_for_localservicerealm_in_file (Shishi * handle,
381 const char *filename,
382 const char *service,
383 const char *realm)
384{
385 char *hostname;
386 char *server;
387 Shishi_key *key;
388
389 hostname = xgethostname ();
390
391 asprintf (&server, "%s/%s", service, hostname);
392
393 key = shishi_keys_for_serverrealm_in_file (handle, filename, server, realm);
394
395 free (server);
396 free (hostname);
397
398 return key;
399}