089951e2d992d559fa6045915cb79445f3553072
[xfstests-dev.git] / src / locktest.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2000-2003 Silicon Graphics, Inc.
4  * All Rights Reserved.
5  */
6
7 /*
8  * Synchronized byte range lock exerciser
9  */
10
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <malloc.h>
14 #include <fcntl.h>
15 #include <errno.h>
16 #include <string.h>
17 #include <sys/stat.h>
18 #include <sys/socket.h>
19 #include <netinet/in.h>
20 #include <netinet/tcp.h>
21
22 #include <unistd.h>
23 #include <sys/types.h>
24 #include <netdb.h>
25 #include <endian.h>
26 #include <byteswap.h>
27 #include <errno.h>
28 #include <string.h>
29 #define     HEX_2_ASC(x)    ((x) > 9) ? (x)-10+'a' : (x)+'0'
30 #define         FILE_SIZE       1024
31 #define PLATFORM_INIT()     /*no-op*/
32 #define PLATFORM_CLEANUP()  /*no-op*/
33 #define LL                  "ll"
34
35 extern int h_errno;
36
37 #define inet_aton(STRING, INADDRP) \
38     (((INADDRP)->s_addr = inet_addr(STRING)) == -1 ? 0 : 1)
39
40 /* this assumes 32 bit pointers */
41 #define PTR_TO_U64(P) ((unsigned __int64)(unsigned int)(P))
42 #define U64_TO_PTR(T,U) ((T)(void *)(unsigned int)(U))
43
44 #if __BYTE_ORDER == __LITTLE_ENDIAN
45 #define bswap_uint16(x)         (uint16_t)bswap_16(x)
46 #define bswap_uint32(x)         (uint32_t)bswap_32(x)
47 #define bswap_uint64(x)         (uint64_t)bswap_64(x)
48 #else
49 #define bswap_uint16(x)         x
50 #define bswap_uint32(x)         x
51 #define bswap_uint64(x)         x
52 #endif
53
54 #define SOCKET              int
55 #define SOCKET_READ         read
56 #define SOCKET_WRITE        write
57 #define SOCKET_CLOSE(S)     (close(S))
58 #define INVALID_SOCKET      -1
59
60 #define O_BINARY            0
61        
62 #define HANDLE              int
63 #define INVALID_HANDLE      -1
64 #define OPEN(N,F)           (open(N, F|O_CREAT|O_BINARY, 0644))
65 #define SEEK(H, O)          (lseek(H, O, SEEK_SET))
66 #define READ(H, B, L)       (read(H, B, L))
67 #define WRITE(H, B, L)      (write(H, B, L))
68 #define CLOSE(H)            (close(H))
69
70 #define RAND()              (rand())
71 #define SRAND(s)            (srand(s))
72 #define SLEEP(s)            (sleep(s))
73
74 #define MIN(A,B)            (((A)<(B))?(A):(B))
75 #define MAX(A,B)            (((A)>(B))?(A):(B))
76
77 #define ALLOC_ALIGNED(S)    (memalign(65536, S)) 
78 #define FREE_ALIGNED(P)     (free(P)) 
79
80 static char     *prog;
81 static char     *filename = 0;
82 static int      debug = 0;
83 static int      server = 1;
84 static int      maxio = 8192;
85 static int      port = 0;
86 static int      testnumber = -1;
87 static int      saved_errno = 0;
88
89 static SOCKET   s_fd = -1;              /* listen socket    */
90 static SOCKET   c_fd = -1;              /* IPC socket       */
91 static HANDLE   f_fd = INVALID_HANDLE;  /* shared file      */
92 static char     *buf;                   /* I/O buffer       */
93
94 #define         WRLOCK  0
95 #define         RDLOCK  1
96 #define         UNLOCK  2
97 #define         F_CLOSE 3
98 #define         F_OPEN  4
99 #define         WRTEST  5
100 #define         RDTEST  6
101
102 #define         PASS    1
103 #define         FAIL    0
104
105 #define         SERVER  0
106 #define         CLIENT  1
107
108 #define         TEST_NUM        0
109 #define         COMMAND         1
110 #define         OFFSET          2
111 #define         LENGTH          3
112 #define         RESULT          4
113 #define         WHO             5
114 #define         FLAGS           2 /* index 2 is also used for do_open() flag, see below */
115
116 /* 
117  * flags for Mac OS X do_open() 
118  * O_RDONLY     0x0000
119  * O_WRONLY     0x0001  
120  * O_RDWR       0x0002
121  * O_NONBLOCK   0x0004  
122  * O_APPEND     0x0008
123  * O_SHLOCK     0x0010  
124  * O_EXLOCK     0x0020
125  * O_ASYNC      0x0040  
126  * O_FSYNC      0x0080
127  * O_NOFOLLOW   0x0100  
128  * O_CREAT      0x0200
129  * O_TRUNC      0x0400
130  * O_EXCL       0x0800
131  */
132
133 /*
134  * When adding tests be sure to add to both the descriptions AND tests array. 
135  * Also, be sure to undo whatever is set for each test (eg unlock any locks)
136  * There is no need to have a matching client command for each server command
137  * (or vice versa)
138  */
139
140 char *descriptions[] = {
141     /* 1 */"Add a lock to an empty lock list",
142     /* 2 */"Add a lock to the start and end of a list - no overlaps",
143     /* 3 */"Add a lock to the middle of a list - no overlap",
144     /* 4 */"Add different lock types to middle of the list - overlap exact match", 
145     /* 5 */"Add new lock which completely overlaps any old lock in the list", 
146     /* 6 */"Add new lock which itself is completely overlaped by any old lock in the list",
147     /* 7 */"Add new lock which starts before any old lock in the list",
148     /* 8 */"Add new lock which starts in the middle of any old lock in the list and ends after",
149     /* 9 */"Add different new lock types which completely overlaps any old lock in the list",
150     /* 10 */"Add different new locks which are completely overlaped by an old lock in the list",
151     /* 11 */"Add different new lock types which start before the old lock in the list",
152     /* 12 */"Add different new lock types which start in the middle of an old lock in the list and end after",
153     /* 13 */"Add new lock, differing types and processes, to middle of the list - exact overlap match",
154     /* 14 */"Add new lock, differing types and processes, which completely overlap any of the locks in the list",
155     /* 15 */"Add new lock, differing types and processes, which are completely overlaped by locks in the list",
156     /* 16 */"Add new lock, differing types and processes, which start before a lock in the list",
157     /* 17 */"Add new lock, differing types and processes, which starts in the middle of a lock, and ends after",
158     /* 18 */"Acquire write locks with overlapping ranges",
159     /* 19 */"Acquire write locks with non-overlapping ranges extending beyond EOF",
160     /* 20 */"Acquire write locks with overlapping ranges extending beyond EOF",
161     /* 21 */"Acquire write locks on whole files",
162     /* 22 */"Acquire write lock on whole file and range write lock",
163     /* 23 */"Acquire read locks with non-overlapping ranges",
164     /* 24 */"Acquire read locks with overlapping ranges",
165     /* 25 */"Acquire read and write locks with no overlapping ranges",
166     /* 26 */"Acquire read and write locks with overlapping ranges",
167     /* 27 */"Acquire whole file write lock and then close without unlocking (and attempt a lock)",
168     /* 28 */"Acquire two read locks, close and reopen the file, and test if the inital lock is still there",
169     /* 29 */"Verify that F_GETLK for F_WRLCK doesn't require that file be opened for write",
170     #if defined(macosx)
171     /* 30 */"Close the opened file and open the file with SHLOCK, other client will try to open with SHLOCK too",
172     /* 31 */"Close the opened file and open the file with SHLOCK, other client will try to open with EXLOCK",
173     /* 32 */"Close the opened file and open the file with EXLOCK, other client will try to open with EXLOCK too"
174     #endif
175 };
176
177 static int64_t tests[][6] =
178         /*      test #  Action  offset          length          expected        server/client */
179         {       
180         /* Various simple tests exercising the list */
181
182 /* SECTION 1: WRITE and UNLOCK with the same process (SERVER) */
183         /* Add a lock to an empty list */
184                 {1,     WRLOCK, 1,              10,             PASS,           SERVER  }, 
185                 {1,     UNLOCK, 1,              10,             PASS,           SERVER  }, 
186                 
187         /* Add a lock to the start and end of a list - 1, 13 - no overlap */
188                 {2,     WRLOCK, 10,             10,             PASS,           SERVER  }, 
189                 {2,     WRLOCK, 30,             10,             PASS,           SERVER  }, 
190                 {2,     WRLOCK, 50,             10,             PASS,           SERVER  }, 
191                 {2,     WRLOCK, 1,              5,              PASS,           SERVER  }, 
192                 {2,     WRLOCK, 70,             5,              PASS,           SERVER  }, 
193                 
194                 {2,     UNLOCK, 10,             10,             PASS,           SERVER  }, 
195                 {2,     UNLOCK, 30,             10,             PASS,           SERVER  }, 
196                 {2,     UNLOCK, 50,             10,             PASS,           SERVER  }, 
197                 {2,     UNLOCK, 1,              5,              PASS,           SERVER  }, 
198                 {2,     UNLOCK, 70,             5,              PASS,           SERVER  }, 
199                 
200         /* Add a lock to the middle of a list - no overlap */
201                 {3,     WRLOCK, 10,             10,             PASS,           SERVER  }, 
202                 {3,     WRLOCK, 30,             10,             PASS,           SERVER  }, 
203                 {3,     WRLOCK, 50,             10,             PASS,           SERVER  }, 
204                 {3,     WRLOCK, 42,             5,              PASS,           SERVER  }, 
205                 
206                 {3,     UNLOCK, 10,             10,             PASS,           SERVER  }, 
207                 {3,     UNLOCK, 30,             10,             PASS,           SERVER  }, 
208                 {3,     UNLOCK, 50,             10,             PASS,           SERVER  }, 
209                 {3,     UNLOCK, 42,             5,              PASS,           SERVER  }, 
210                 
211         /* Add different lock types to middle of the list - overlap exact match - 3 */
212                 {4,     WRLOCK, 10,             10,             PASS,           SERVER  }, 
213                 {4,     WRLOCK, 30,             10,             PASS,           SERVER  }, 
214                 {4,     WRLOCK, 50,             10,             PASS,           SERVER  }, 
215                 /* Exact match - same lock type */
216                 {4,     WRLOCK, 30,             10,             PASS,           SERVER  }, 
217                 /* Exact match - different lock type */
218                 {4,     RDLOCK, 30,             10,             PASS,           SERVER  }, 
219                 /* Exact match - unlock */
220                 {4,     UNLOCK, 30,             10,             PASS,           SERVER  }, 
221                 /* New lock - as above, inserting in the list again */
222                 {4,     WRLOCK, 30,             10,             PASS,           SERVER  }, 
223                 
224                 {4,     UNLOCK, 10,             10,             PASS,           SERVER  }, 
225                 {4,     UNLOCK, 30,             10,             PASS,           SERVER  }, 
226                 {4,     UNLOCK, 50,             10,             PASS,           SERVER  }, 
227                 
228         /* Add new lock which completely overlaps any old lock in the list - 4,5,6 */
229                 {5,     WRLOCK, 10,             10,             PASS,           SERVER  }, 
230                 {5,     WRLOCK, 30,             10,             PASS,           SERVER  }, 
231                 {5,     WRLOCK, 50,             10,             PASS,           SERVER  }, 
232                 /* The start is the same, end overlaps */
233                 {5,     WRLOCK, 30,             15,             PASS,           SERVER  }, 
234                 /* The start is before, end is the same */
235                 {5,     WRLOCK, 25,             20,             PASS,           SERVER  }, 
236                 /* Both start and end overlap */
237                 {5,     WRLOCK, 22,             26,             PASS,           SERVER  }, 
238                 
239                 {5,     UNLOCK, 10,             10,             PASS,           SERVER  }, 
240                 {5,     UNLOCK, 22,             26,             PASS,           SERVER  }, 
241                 {5,     UNLOCK, 50,             10,             PASS,           SERVER  }, 
242                 
243         /* Add new lock which itself is completely overlaped by any old lock in the list - 7,8,10 */
244                 {6,     WRLOCK, 10,             10,             PASS,           SERVER  }, 
245                 {6,     WRLOCK, 30,             10,             PASS,           SERVER  }, 
246                 {6,     WRLOCK, 50,             10,             PASS,           SERVER  }, 
247                 /* The start is the same, end is in the middle of old lock - NOP */
248                 {6,     WRLOCK, 30,             5,              PASS,           SERVER  }, 
249                 /* The start and end are in the middle of old lock - NOP */
250                 {6,     WRLOCK, 32,             6,              PASS,           SERVER  }, 
251                 /* Start in the middle and end is the same - NOP */
252                 {6,     WRLOCK, 32,             8,              PASS,           SERVER  }, 
253                 
254                 {6,     UNLOCK, 10,             10,             PASS,           SERVER  }, 
255                 {6,     UNLOCK, 30,             10,             PASS,           SERVER  }, 
256                 {6,     UNLOCK, 32,             8,              PASS,           SERVER  }, 
257                 {6,     UNLOCK, 50,             10,             PASS,           SERVER  }, 
258                 
259         /* Add new lock which starts before any old lock in the list - 2,9 */
260                 {7,     WRLOCK, 10,             10,             PASS,           SERVER  }, 
261                 {7,     WRLOCK, 30,             10,             PASS,           SERVER  }, 
262                 {7,     WRLOCK, 50,             10,             PASS,           SERVER  }, 
263                 /* Here is the new lock */
264                 {7,     WRLOCK, 27,             10,             PASS,           SERVER  }, 
265                 /* Go again with the end of the new lock matching the start of old lock */
266                 {7,     WRLOCK, 25,             2,              PASS,           SERVER  }, 
267                 
268                 {7,     UNLOCK, 10,             10,             PASS,           SERVER  }, 
269                 {7,     UNLOCK, 25,             15,             PASS,           SERVER  }, 
270                 {7,     UNLOCK, 50,             10,             PASS,           SERVER  }, 
271         
272         /* Add new lock which starts in the middle of any old lock in the list and ends after - 11,12 */
273                 {8,     WRLOCK, 10,             10,             PASS,           SERVER  }, 
274                 {8,     WRLOCK, 30,             10,             PASS,           SERVER  }, 
275                 {8,     WRLOCK, 50,             10,             PASS,           SERVER  }, 
276                 /* Here is the new lock */
277                 {8,     WRLOCK, 35,             10,             PASS,           SERVER  }, 
278                 /* Go again with the end of the new lock matching the start of old lock */
279                 {8,     WRLOCK, 45,             2,              PASS,           SERVER  }, 
280                 
281                 {8,     UNLOCK, 10,             10,             PASS,           SERVER  }, 
282                 {8,     UNLOCK, 30,             17,             PASS,           SERVER  }, 
283                 {8,     UNLOCK, 50,             10,             PASS,           SERVER  }, 
284 /* SECTION 2: Overlapping READ and WRITE and UNLOCK with the same process (SERVER) */
285         /* Add different new lock types which completely overlaps any old lock in the list - 4,5,6 */
286                 {9,     WRLOCK, 10,             10,             PASS,           SERVER  }, 
287                 {9,     WRLOCK, 30,             10,             PASS,           SERVER  }, 
288                 {9,     WRLOCK, 50,             10,             PASS,           SERVER  }, 
289                 /* The start is the same, end overlaps */
290                 {9,     RDLOCK, 30,             15,             PASS,           SERVER  }, 
291                 /* The start is before, end is the same */
292                 {9,     WRLOCK, 25,             20,             PASS,           SERVER  }, 
293                 /* Both start and end overlap */
294                 {9,     RDLOCK, 22,             26,             PASS,           SERVER  }, 
295                 
296                 {9,     UNLOCK, 10,             10,             PASS,           SERVER  }, 
297                 {9,     UNLOCK, 22,             26,             PASS,           SERVER  }, 
298                 {9,     UNLOCK, 50,             10,             PASS,           SERVER  }, 
299                 
300         /* Add different new locks which are completely overlaped by an old lock in the list - 7,8,10 */
301                 {10,    WRLOCK, 10,             10,             PASS,           SERVER  }, 
302                 {10,    WRLOCK, 30,             10,             PASS,           SERVER  }, 
303                 {10,    WRLOCK, 50,             10,             PASS,           SERVER  }, 
304                 /* The start is the same, end is in the middle of old lock */
305                 {10,    RDLOCK, 30,             5,              PASS,           SERVER  }, 
306                 /* The start and end are in the middle of a lock */
307                 {10,    WRLOCK, 32,             2,              PASS,           SERVER  }, 
308                 /* Start in the middle and end is the same */
309                 {10,    RDLOCK, 36,             5,              PASS,           SERVER  }, 
310                 
311                 {10,    UNLOCK, 10,             10,             PASS,           SERVER  }, 
312                 {10,    UNLOCK, 30,             11,             PASS,           SERVER  }, 
313                 {10,    UNLOCK, 50,             10,             PASS,           SERVER  }, 
314                 
315         /* Add different new lock types which start before the old lock in the list - 2,9 */
316                 {11,    WRLOCK, 10,             10,             PASS,           SERVER  }, 
317                 {11,    WRLOCK, 30,             10,             PASS,           SERVER  }, 
318                 {11,    WRLOCK, 50,             10,             PASS,           SERVER  }, 
319                 /* Here is the new lock */
320                 {11,    RDLOCK, 27,             10,             PASS,           SERVER  }, 
321                 /* Go again with the end of the new lock matching the start of lock */
322                 {11,    WRLOCK, 25,             3,              PASS,           SERVER  }, 
323                 
324                 {11,    UNLOCK, 10,             10,             PASS,           SERVER  }, 
325                 {11,    UNLOCK, 25,             15,             PASS,           SERVER  }, 
326                 {11,    UNLOCK, 50,             10,             PASS,           SERVER  }, 
327         
328         /* Add different new lock types which start in the middle of an old lock in the list and end after - 11,12 */
329                 {12,    WRLOCK, 10,             10,             PASS,           SERVER  }, 
330                 {12,    WRLOCK, 30,             10,             PASS,           SERVER  }, 
331                 {12,    WRLOCK, 50,             10,             PASS,           SERVER  }, 
332                 /* Here is the new lock */
333                 {12,    RDLOCK, 35,             10,             PASS,           SERVER  }, 
334                 /* Go again with the end of the new lock matching the start of old lock */
335                 {12,    WRLOCK, 44,             3,              PASS,           SERVER  }, 
336                 
337                 {12,    UNLOCK, 10,             10,             PASS,           SERVER  }, 
338                 {12,    UNLOCK, 30,             18,             PASS,           SERVER  }, 
339                 {12,    UNLOCK, 50,             10,             PASS,           SERVER  }, 
340
341 /* SECTION 3: Overlapping READ and WRITE and UNLOCK with the different processes (CLIENT/SERVER) */
342         /* Add new lock, differing types and processes, to middle of the list - exact overlap match - 3 */
343                 {13,    WRLOCK, 10,             10,             PASS,           SERVER  }, 
344                 {13,    WRLOCK, 30,             10,             PASS,           SERVER  }, 
345                 {13,    RDLOCK, 50,             10,             PASS,           SERVER  }, 
346                 /* Same lock type, different process */
347                 {13,    WRLOCK, 30,             10,             FAIL,           CLIENT  }, 
348                 {13,    RDLOCK, 50,             10,             PASS,           CLIENT  }, 
349                 /* Exact match - different lock type, different process */
350                 {13,    RDLOCK, 30,             10,             FAIL,           CLIENT  }, 
351                 /* Exact match - unlock */
352                 {13,    UNLOCK, 30,             10,             PASS,           CLIENT  }, 
353                 /* New lock - as above, inserting in the list again */
354                 {13,    UNLOCK, 30,             10,             PASS,           SERVER  }, 
355                 /* Exact match - same lock type, different process */
356                 {13,    WRLOCK, 30,             10,             PASS,           CLIENT  }, 
357                 
358                 {13,    UNLOCK, 10,             10,             PASS,           SERVER  }, 
359                 {13,    UNLOCK, 30,             10,             PASS,           CLIENT  }, 
360                 {13,    UNLOCK, 50,             10,             PASS,           SERVER  }, 
361                 
362         /* Add new lock, differing types and processes, which completely overlap any of the locks in the list - 4,5,6 */
363                 {14,    WRLOCK, 10,             10,             PASS,           SERVER  }, 
364                 {14,    WRLOCK, 30,             10,             PASS,           SERVER  }, 
365                 {14,    RDLOCK, 50,             10,             PASS,           SERVER  }, 
366                 /* The start is the same, end overlaps */
367                 {14,    RDLOCK, 30,             15,             FAIL,           CLIENT  },
368                 {14,    WRLOCK, 30,             15,             FAIL,           CLIENT  }, 
369                 /* The start is before, end is the same */
370                 {14,    RDLOCK, 25,             20,             FAIL,           CLIENT  }, 
371                 {14,    WRLOCK, 25,             20,             FAIL,           CLIENT  }, 
372                 /* Both start and end overlap */
373                 {14,    RDLOCK, 22,             26,             FAIL,           CLIENT  }, 
374                 {14,    WRLOCK, 22,             26,             FAIL,           CLIENT  }, 
375                 
376                 /* The start is the same, end overlaps */
377                 {14,    RDLOCK, 50,             15,             PASS,           CLIENT  },
378                 {14,    WRLOCK, 50,             17,             FAIL,           CLIENT  }, 
379                 /* The start is before, end is the same */
380                 {14,    RDLOCK, 45,             20,             PASS,           CLIENT  }, 
381                 {14,    WRLOCK, 43,             22,             FAIL,           CLIENT  }, 
382                 /* Both start and end overlap */
383                 {14,    RDLOCK, 42,             26,             PASS,           CLIENT  }, 
384                 {14,    WRLOCK, 41,             28,             FAIL,           CLIENT  }, 
385                 
386                 {14,    UNLOCK, 10,             10,             PASS,           SERVER  }, 
387                 {14,    UNLOCK, 22,             26,             PASS,           SERVER  }, 
388                 {14,    UNLOCK, 42,             26,             PASS,           CLIENT  }, 
389
390         /* Add new lock, differing types and processes, which are completely overlaped by an old lock in the list - 7,8,10 */
391                 {15,    WRLOCK, 10,             10,             PASS,           SERVER  }, 
392                 {15,    RDLOCK, 30,             10,             PASS,           SERVER  }, 
393                 {15,    WRLOCK, 50,             10,             PASS,           SERVER  }, 
394                 /* The start is the same, end is in the middle of old lock */
395                 {15,    RDLOCK, 50,             5,              FAIL,           CLIENT  }, 
396                 {15,    WRLOCK, 50,             5,              FAIL,           CLIENT  }, 
397                 /* The start and end are in the middle of old lock */
398                 {15,    RDLOCK, 52,             6,              FAIL,           CLIENT  }, 
399                 {15,    WRLOCK, 52,             6,              FAIL,           CLIENT  }, 
400                 /* Start in the middle and end is the same */
401                 {15,    RDLOCK, 52,             8,              FAIL,           CLIENT  }, 
402                 {15,    WRLOCK, 52,             8,              FAIL,           CLIENT  }, 
403                 /* The start is the same, end is in the middle of old lock */
404                 {15,    RDLOCK, 30,             5,              PASS,           CLIENT  }, 
405                 {15,    WRLOCK, 30,             5,              FAIL,           CLIENT  }, 
406                 /* The start and end are in the middle of old lock */
407                 {15,    RDLOCK, 32,             6,              PASS,           CLIENT  }, 
408                 {15,    WRLOCK, 32,             6,              FAIL,           CLIENT  }, 
409                 /* Start in the middle and end is the same */
410                 {15,    RDLOCK, 32,             8,              PASS,           CLIENT  }, 
411                 {15,    WRLOCK, 32,             8,              FAIL,           CLIENT  }, 
412                 
413                 {15,    UNLOCK, 10,             10,             PASS,           SERVER  }, 
414                 {15,    UNLOCK, 30,             10,             PASS,           SERVER  }, 
415                 {15,    UNLOCK, 50,             10,             PASS,           SERVER  }, 
416         /* Add new lock, differing types and processes, which start before a lock in the list - 2,9 */
417                 {16,    RDLOCK, 10,             10,             PASS,           SERVER  }, 
418                 {16,    WRLOCK, 50,             10,             PASS,           SERVER  }, 
419                 /* Start is before, end is the start of the old lock in list */
420                 {16,    RDLOCK, 5,              6,              PASS,           CLIENT  }, 
421                 {16,    WRLOCK, 5,              6,              FAIL,           CLIENT  }, 
422                 /* Start is before, end is in the middle of the old lock */
423                 {16,    RDLOCK, 5,              10,             PASS,           CLIENT  }, 
424                 {16,    WRLOCK, 5,              10,             FAIL,           CLIENT  }, 
425                 /* Start is before, end is the start of the old lock in list */
426                 {16,    RDLOCK, 45,             6,              FAIL,           CLIENT  }, 
427                 {16,    WRLOCK, 45,             6,              FAIL,           CLIENT  }, 
428                 /* Start is before, end is in the middle of the old lock */
429                 {16,    RDLOCK, 45,             10,             FAIL,           CLIENT  }, 
430                 {16,    WRLOCK, 45,             10,             FAIL,           CLIENT  }, 
431                 
432                 {16,    UNLOCK, 5,              15,             PASS,           CLIENT  }, 
433                 {16,    UNLOCK, 30,             10,             PASS,           SERVER  }, 
434                 {16,    UNLOCK, 50,             10,             PASS,           SERVER  }, 
435
436         /* Add new lock, differing types and processes, which starts in the middle of a lock, and ends after - 11,12 */
437                 {17,    WRLOCK, 10,             10,             PASS,           SERVER  }, 
438                 {17,    RDLOCK, 30,             10,             PASS,           SERVER  }, 
439                 {17,    WRLOCK, 50,             10,             PASS,           SERVER  }, 
440                 /* Start in the middle, end after lock in list */
441                 {17,    WRLOCK, 35,             10,             FAIL,           CLIENT  }, 
442                 /* Start matches end of lock in list  */
443                 {17,    RDLOCK, 35,             10,             PASS,           CLIENT  }, 
444                 {17,    RDLOCK, 44,             2,              PASS,           CLIENT  }, 
445                 /* Start in the middle, end after lock in list */
446                 {17,    RDLOCK, 55,             10,             FAIL,           CLIENT  }, 
447                 {17,    WRLOCK, 55,             10,             FAIL,           CLIENT  }, 
448                 /* Start matches end of lock in list  */
449                 {17,    RDLOCK, 59,             5,              FAIL,           CLIENT  }, 
450                 {17,    WRLOCK, 59,             5,              FAIL,           CLIENT  }, 
451                 
452                 {17,    UNLOCK, 10,             10,             PASS,           SERVER  }, 
453                 {17,    UNLOCK, 30,             16,             PASS,           CLIENT  }, 
454                 {17,    UNLOCK, 50,             10,             PASS,           SERVER  }, 
455
456 /* SECTION 4: overlapping and EOF tests */
457         /* Acquire overlapping ranges */
458                 {18,    WRLOCK, 11,             7,              PASS,           SERVER  },
459                 {18,    WRLOCK, 13,             8,              FAIL,           CLIENT  },
460                 {18,    UNLOCK, 11,             7,              PASS,           SERVER  },
461         /* Acquire different ranges beyond EOF */
462                 {19,    WRLOCK, 10,             FILE_SIZE,      PASS,           SERVER  },
463                 {19,    WRLOCK, FILE_SIZE + 10, 10,             PASS,           CLIENT  },
464                 {19,    UNLOCK, 10,             FILE_SIZE,      PASS,           SERVER  },
465                 {19,    UNLOCK, FILE_SIZE + 10, 10,             PASS,           CLIENT  },
466         /* Acquire same range beyong EOF */
467                 {20,    WRLOCK, 10,             FILE_SIZE,      PASS,           SERVER, },
468                 {20,    WRLOCK, 10,             FILE_SIZE,      FAIL,           CLIENT, },
469                 {20,    UNLOCK, 10,             FILE_SIZE,      PASS,           SERVER, },
470         /* Acquire whole file lock */
471                 {21,    WRLOCK, 0,              0,              PASS,           SERVER, },
472                 {21,    WRLOCK, 0,              0,              FAIL,           CLIENT, },
473                 {21,    UNLOCK, 0,              0,              PASS,           SERVER, },
474         /* Acquire whole file lock, then range */
475                 {22,    WRLOCK, 0,              0,              PASS,           SERVER, },
476                 {22,    WRLOCK, 1,              5,              FAIL,           CLIENT, },
477                 {22,    UNLOCK, 0,              0,              PASS,           SERVER, },
478         /* Acquire non-overlapping read locks */
479                 {23,    RDLOCK, 1,              5,              PASS,           SERVER, },
480                 {23,    RDLOCK, 7,              6,              PASS,           CLIENT, },
481                 {23,    UNLOCK, 1,              5,              PASS,           SERVER, },
482                 {23,    UNLOCK, 7,              6,              PASS,           CLIENT, },
483         /* Acquire overlapping read locks */
484                 {24,    RDLOCK, 1,              5,              PASS,           SERVER, },
485                 {24,    RDLOCK, 2,              6,              PASS,           CLIENT, },
486                 {24,    UNLOCK, 1,              5,              PASS,           SERVER, },
487                 {24,    UNLOCK, 1,              7,              PASS,           CLIENT, },
488         /* Acquire non-overlapping read and write locks */
489                 {25,    RDLOCK, 1,              5,              PASS,           SERVER, },
490                 {25,    WRLOCK, 7,              6,              PASS,           CLIENT, },
491                 {25,    UNLOCK, 1,              5,              PASS,           SERVER, },
492                 {25,    UNLOCK, 7,              6,              PASS,           CLIENT, },
493         /* Acquire overlapping read and write locks */
494                 {26,    RDLOCK, 1,              5,              PASS,           SERVER, },
495                 {26,    WRLOCK, 2,              6,              FAIL,           CLIENT, },
496                 {26,    UNLOCK, 1,              5,              PASS,           SERVER, },
497         /* Acquire whole file lock, then close (without unlocking) */
498                 {27,    WRLOCK, 0,              0,              PASS,           SERVER, },
499                 {27,    WRLOCK, 1,              5,              FAIL,           CLIENT, },
500                 {27,    F_CLOSE,0,              0,              PASS,           SERVER, },
501                 {27,    WRLOCK, 1,              5,              PASS,           CLIENT, },
502                 {27,    F_OPEN, O_RDWR,         0,              PASS,           SERVER, },
503                 {27,    UNLOCK, 1,              5,              PASS,           CLIENT, },
504         /* Acquire two read locks, close one file and then reopen to check that first lock still exists */
505                 {28,    RDLOCK, 1,              5,              PASS,           SERVER, },
506                 {28,    RDLOCK, 1,              5,              PASS,           CLIENT, },
507                 {28,    F_CLOSE,0,              0,              PASS,           SERVER, },
508                 {28,    F_OPEN, O_RDWR,         0,              PASS,           SERVER, },
509                 {28,    WRLOCK, 0,              0,              FAIL,           SERVER, },
510                 {28,    UNLOCK, 1,              5,              PASS,           SERVER, },
511         /* Verify that F_GETLK for F_WRLCK doesn't require that file be opened for write */
512                 {29,    F_CLOSE, 0,             0,              PASS,           SERVER, },
513                 {29,    F_OPEN, O_RDONLY,       0,              PASS,           SERVER, },
514                 {29,    WRTEST, 0,              0,              PASS,           SERVER, },
515                 {29,    F_CLOSE,0,              0,              PASS,           SERVER, },
516                 {29,    F_OPEN, O_RDWR,         0,              PASS,           SERVER, },
517 #ifdef macosx
518         /* Close the opened file and open the file with SHLOCK, other client will try to open with SHLOCK too */
519                 {30,    F_CLOSE,0,              0,              PASS,           SERVER, },
520                 {30,    F_OPEN, O_RDWR|O_SHLOCK|O_NONBLOCK,     0,      PASS,           SERVER, },
521                 {30,    F_CLOSE,0,              0,              PASS,           CLIENT, },
522                 {30,    F_OPEN, O_RDWR|O_SHLOCK|O_NONBLOCK,     0,      PASS,           CLIENT, },
523         /* Close the opened file and open the file with SHLOCK, other client will try to open with EXLOCK */
524                 {31,    F_CLOSE,0,              0,              PASS,           SERVER, },
525                 {31,    F_CLOSE,0,              0,              PASS,           CLIENT, },
526                 {31,    F_OPEN, O_RDWR|O_SHLOCK|O_NONBLOCK,     0,      PASS,           SERVER, },
527                 {31,    F_OPEN, O_RDWR|O_EXLOCK|O_NONBLOCK,     0,      FAIL,           CLIENT, },
528         /* Close the opened file and open the file with EXLOCK, other client will try to open with EXLOCK too */
529                 {32,    F_CLOSE,0,              0,              PASS,           SERVER, },
530                 {32,    F_CLOSE,0,              0,              FAIL,           CLIENT, },
531                 {32,    F_OPEN, O_RDWR|O_EXLOCK|O_NONBLOCK,     0,      PASS,           SERVER, },
532                 {32,    F_OPEN, O_RDWR|O_EXLOCK|O_NONBLOCK,     0,      FAIL,           CLIENT, },
533                 {32,    F_CLOSE,0,              0,              PASS,           SERVER, },
534                 {32,    F_CLOSE,0,              0,              FAIL,           CLIENT, },
535                 {32,    F_OPEN, O_RDWR,         0,              PASS,           SERVER, },
536                 {32,    F_OPEN, O_RDWR,         0,              PASS,           CLIENT, },
537 #endif /* macosx */
538         /* indicate end of array */
539                 {0,0,0,0,0,SERVER},
540                 {0,0,0,0,0,CLIENT}
541         };
542
543 static struct {
544     int32_t             test;
545     int32_t             command;
546     int64_t             offset;
547     int64_t             length;
548     int32_t             result;
549     int32_t             index;
550     int32_t             error;
551     int32_t             padding; /* So mac and irix have the same size struct (bloody alignment) */
552 } ctl;
553
554
555 void
556 usage(void)
557 {
558     fprintf(stderr, "Usage: %s [options] sharedfile\n\
559 \n\
560 options:\n\
561   -p port       TCP/IP port number for client-server communication\n\
562   -d            enable debug tracing\n\
563   -n #          test number to run\n\
564   -h host       run as client and connect to server on remote host\n\
565                 [default run as server]\n", prog);
566     exit(1);
567 }
568
569 #define INIT_BUFSZ 512 
570
571 void
572 initialize(HANDLE fd)
573 {
574     char*       ibuf;
575     int         j=0;
576     int         nwrite;
577     int         offset = 0;
578     int         togo = FILE_SIZE;
579
580     ibuf = (char*)malloc(INIT_BUFSZ);
581     memset(ibuf, ':', INIT_BUFSZ);
582
583     SEEK(fd, 0L);
584     while (togo) {
585         offset+=j;
586         j = togo > INIT_BUFSZ ? INIT_BUFSZ : togo;
587
588         if ((nwrite = WRITE(fd, ibuf, j)) != j) {
589             if (nwrite < 0)
590                 perror("initialize write:");
591             else
592                 fprintf(stderr, "initialize: write() returns %d, not %d as expected\n", 
593                         nwrite, j);
594             exit(1);
595             /*NOTREACHED*/
596         }
597         togo -= j;
598     }
599 }
600
601
602 int do_open(int flag)
603 {
604     if ((f_fd = OPEN(filename, flag)) == INVALID_HANDLE) {
605         perror("shared file create");
606         return FAIL;
607         /*NOTREACHED*/
608     }
609
610     return PASS;
611 }
612
613 static int do_lock(int cmd, int type, int start, int length)
614 {
615     int ret;
616     int filedes = f_fd;
617     struct flock fl;
618
619     if(debug > 1) {
620         fprintf(stderr, "do_lock: cmd=%d type=%d start=%d, length=%d\n", cmd, type, start, length);
621     }
622
623     if (f_fd < 0)
624         return f_fd;
625     
626     fl.l_start = start;
627     fl.l_len = length;
628     fl.l_whence = SEEK_SET;
629     fl.l_pid = getpid();
630     fl.l_type = type;
631
632     errno = 0;
633
634     ret = fcntl(filedes, cmd, &fl);
635     saved_errno = errno;            
636
637     if(debug > 1 && ret)
638         fprintf(stderr, "do_lock: ret = %d, errno = %d (%s)\n", ret, errno, strerror(errno));
639
640     return(ret==0?PASS:FAIL);
641 }
642
643 int do_close(void)
644 {       
645     if(debug > 1) {
646         fprintf(stderr, "do_close\n");
647     }
648
649     errno =0;
650     CLOSE(f_fd);
651     f_fd = INVALID_HANDLE;
652
653     saved_errno = errno;            
654         
655     if (errno)
656         return FAIL;
657     return PASS;
658 }
659
660 void
661 send_ctl(void)
662 {
663     int         nwrite;
664
665     if (debug > 1) {
666         fprintf(stderr, "send_ctl: test=%d, command=%d offset=%"LL"d, length=%"LL"d, result=%d, error=%d\n", 
667                 ctl.test, ctl.command, (long long)ctl.offset, (long long)ctl.length,ctl.result, ctl.error);
668     }
669
670     ctl.test= bswap_uint32(ctl.test);
671     ctl.command = bswap_uint32(ctl.command);
672     ctl.offset = bswap_uint64(ctl.offset);
673     ctl.length = bswap_uint64(ctl.length);
674     ctl.result = bswap_uint32(ctl.result);
675     ctl.index= bswap_uint32(ctl.index);
676     ctl.error = bswap_uint32(ctl.error);
677     nwrite = SOCKET_WRITE(c_fd, (char*)&ctl, sizeof(ctl));
678
679     ctl.test= bswap_uint32(ctl.test);
680     ctl.command = bswap_uint32(ctl.command);
681     ctl.offset = bswap_uint64(ctl.offset);
682     ctl.length = bswap_uint64(ctl.length);
683     ctl.result = bswap_uint32(ctl.result);
684     ctl.index= bswap_uint32(ctl.index);
685     ctl.error= bswap_uint32(ctl.error);
686     if (nwrite != sizeof(ctl)) {
687         if (nwrite < 0)
688             perror("send_ctl: write");
689         else
690             fprintf(stderr, "send_ctl[%d]: write() returns %d, not %zu as expected\n", 
691                     ctl.test, nwrite, sizeof(ctl));
692         exit(1);
693         /*NOTREACHED*/
694     }
695 }
696
697 void recv_ctl(void)
698 {
699     int         nread;
700
701     if ((nread = SOCKET_READ(c_fd, (char*)&ctl, sizeof(ctl))) != sizeof(ctl)) {
702         if (nread < 0)
703             perror("recv_ctl: read");
704         else {
705             fprintf(stderr, "recv_ctl[%d]: read() returns %d, not %zu as expected\n", 
706                     ctl.test, nread, sizeof(ctl));
707             fprintf(stderr, "socket might has been closed by other locktest\n");
708         } 
709         exit(1);
710         /*NOTREACHED*/
711     }
712     ctl.test= bswap_uint32(ctl.test);
713     ctl.command = bswap_uint32(ctl.command);
714     ctl.offset = bswap_uint64(ctl.offset);
715     ctl.length = bswap_uint64(ctl.length);
716     ctl.result = bswap_uint32(ctl.result);
717     ctl.index= bswap_uint32(ctl.index);
718     ctl.error= bswap_uint32(ctl.error);
719
720     if (debug > 1) {
721         fprintf(stderr, "recv_ctl: test=%d, command=%d offset=%"LL"d, length=%"LL"d, result=%d, error=%d\n", 
722                 ctl.test, ctl.command, (long long)ctl.offset, (long long)ctl.length, ctl.result, ctl.error);
723     }
724 }
725
726 void
727 cleanup(void)
728 {
729     if (f_fd>=0)
730         CLOSE(f_fd);
731     
732     if (c_fd>=0)
733         SOCKET_CLOSE(c_fd);
734     
735     if (s_fd>=0)
736         SOCKET_CLOSE(s_fd);
737     
738     PLATFORM_CLEANUP();
739 }
740
741 int
742 main(int argc, char *argv[])
743 {
744     int         i, sts;
745     int         c;
746     struct sockaddr_in  myAddr;
747     struct linger       noLinger = {1, 0};
748     char        *host = NULL;
749     char        *endnum;
750     int         errflag = 0;
751     char        *p;
752     extern char *optarg;
753     extern int  optind;
754     int fail_count = 0;; 
755     
756     atexit(cleanup);
757     
758     PLATFORM_INIT();
759
760     /* trim command name of leading directory components */
761     prog = argv[0];
762     for (p = prog; *p; p++) {
763         if (*p == '/')
764             prog = p+1;
765     }
766
767     while ((c = getopt(argc, argv, "dn:h:p:?")) != EOF) {
768         switch (c) {
769
770         case 'd':       /* debug flag */
771             debug++;
772             break;
773
774         case 'h':       /* (server) hostname */
775             server = 0;
776             host = optarg;
777             break;
778
779         case 'n':
780             testnumber = atoi(optarg);
781             break;
782
783         case 'p':       /* TCP/IP port */
784             port = (int)strtol(optarg, &endnum, 10);
785             if (*endnum != '\0') {
786                 fprintf(stderr, "%s: -p argument must be a numeric\n", 
787                         prog);
788                 exit(1);
789                 /*NOTREACHED*/
790             }
791             break;
792
793         case '?':
794         default:
795             errflag++;
796             break;
797         }
798     }
799
800     if (errflag || optind != argc-1) {
801         usage();
802         /*NOTREACHED*/
803     }
804
805     filename=argv[optind];
806     if (do_open(O_RDWR) == FAIL)
807         exit(1);
808
809     /*
810      * +10 is slop for the iteration number if do_write() ... never
811      * needed unless maxio is very small
812      */
813     if ((buf = (char *)malloc(maxio + 10)) == NULL) {
814         perror("malloc buf");
815         exit(1);
816         /*NOTREACHED*/
817     }
818
819     setbuf(stderr, NULL);
820
821     if (server) {
822         int one = 1;
823         
824         s_fd = socket(AF_INET, SOCK_STREAM, 0);
825         if (s_fd == INVALID_SOCKET) {
826             perror("socket");
827             exit(1);
828             /*NOTREACHED*/
829         }
830         if (setsockopt(s_fd, IPPROTO_TCP, TCP_NODELAY, (char*)&one, sizeof(one)) < 0) {
831             perror("setsockopt(nodelay)");
832             exit(1);
833             /*NOTREACHED*/
834         }
835         if (setsockopt(s_fd, SOL_SOCKET, SO_REUSEADDR, (char*)&one, sizeof(one))<0) {
836             perror("setsockopt(reuseaddr)");
837             exit(1);
838             /*NOTREACHED*/
839         }
840 #ifdef SO_REUSEPORT
841         if (setsockopt(s_fd, SOL_SOCKET, SO_REUSEPORT, (char*)&one, sizeof(one))<0) {
842             perror("setsockopt(reuseport)");
843             exit(1);
844             /*NOTREACHED*/
845         }
846 #endif
847
848         memset(&myAddr, 0, sizeof(myAddr));
849         myAddr.sin_family = AF_INET;
850         myAddr.sin_addr.s_addr = htonl(INADDR_ANY);
851         myAddr.sin_port = htons((short)port);
852         sts = bind(s_fd, (struct sockaddr*)&myAddr, sizeof(myAddr));
853         if (sts < 0) {
854             perror("bind");
855             exit(1);
856             /*NOTREACHED*/
857         }
858
859         sts = listen(s_fd, 5);  /* Max. of 5 pending connection requests */
860         if (sts == -1) {
861             perror("listen");
862             exit(1);
863             /*NOTREACHED*/
864         }
865
866         if (port == 0) {
867                 socklen_t addr_len = sizeof(myAddr);
868
869                 if (getsockname(s_fd, &myAddr, &addr_len)) {
870                     perror("getsockname");
871                     exit(1);
872                 }
873
874                 port = ntohs(myAddr.sin_port);
875         }
876
877         printf("server port: %d\n", port);
878         fflush(stdout);
879
880         c_fd = accept(s_fd, NULL, NULL);
881         if (c_fd == INVALID_SOCKET) {
882             perror("accept");
883             exit(1);
884             /*NOTREACHED*/
885         }
886
887         if (debug) fprintf(stderr, "Client accepted\n");
888         SRAND(12345L);
889     }
890     else {
891         struct hostent  *servInfo;
892
893         if ((servInfo = gethostbyname(host)) == NULL) {
894             printf("Couldn't get hostbyname for %s", host);
895             if (h_errno == HOST_NOT_FOUND)
896                 printf(": host not found");
897             printf("\n");
898             exit(1);
899             /*NOTREACHED*/
900         }
901
902         c_fd = socket(AF_INET, SOCK_STREAM, 0);
903         if (c_fd == INVALID_SOCKET) {
904             perror("socket");
905             exit(1);
906             /*NOTREACHED*/
907         }
908         /* avoid 200 ms delay */
909         if (setsockopt(c_fd, IPPROTO_TCP, TCP_NODELAY, (char *)&i, sizeof(i)) < 0) {
910             perror("setsockopt(nodelay)");
911             exit(1);
912             /*NOTREACHED*/
913         }
914         /* Don't linger on close */
915         if (setsockopt(c_fd, SOL_SOCKET, SO_LINGER, (char *)&noLinger, sizeof(noLinger)) < 0) {
916             perror("setsockopt(nolinger)");
917             exit(1);
918             /*NOTREACHED*/
919         }
920
921         memset(&myAddr, 0, sizeof(myAddr));     /* Arrgh! &myAddr, not myAddr */
922         myAddr.sin_family = AF_INET;
923         memcpy(&myAddr.sin_addr, servInfo->h_addr, servInfo->h_length);
924         myAddr.sin_port = htons((short)port);
925
926         if (connect(c_fd, (struct sockaddr*)&myAddr, sizeof(myAddr)) < 0) {
927             perror("unable to connect");
928             fprintf(stderr, "Server might still initializing the shared file\n ");
929             exit(1);
930             /*NOTREACHED*/
931         }
932
933         if (debug) fprintf(stderr, "Connected to server\n");
934         SRAND(6789L);
935     }
936
937     if (server)
938         /* only server need do shared file */
939         initialize(f_fd);
940
941     /*
942      * TCP/IP connection to be established, safe to proceed.
943      *
944      * real work is in here ...
945      */
946     i = 0;
947 {
948     int index = 0;
949     int end = 0;
950     int result = 0;
951     int last_test = 0;
952     int test_count = 0;
953     int fail_flag = 0;
954     while(!end) {
955         if (server) {
956             if(testnumber > 0) {
957                 last_test = testnumber - 1;
958                 while(tests[index][TEST_NUM] != testnumber && tests[index][TEST_NUM] != 0) {
959                     index++;
960                 }
961             }
962             /* If we have a server command, deal with it */
963             if(tests[index][WHO] == SERVER) {
964                 if(debug>1)
965                     fprintf(stderr, "Got a server command (%d)\n", index);
966                 if(tests[index][TEST_NUM] == 0) {
967                     index++;
968                     continue;
969                 } 
970                 memset(&ctl, 0, sizeof(ctl));
971                 ctl.test = tests[index][TEST_NUM];
972
973                 if(tests[index][TEST_NUM] != 0) {
974                     switch(tests[index][COMMAND]) {
975                         case WRLOCK:
976                             result = do_lock(F_SETLK, F_WRLCK, tests[index][OFFSET], tests[index][LENGTH]);
977                             break;
978                         case RDLOCK:
979                             result = do_lock(F_SETLK, F_RDLCK, tests[index][OFFSET], tests[index][LENGTH]);
980                             break;
981                         case UNLOCK:
982                             result = do_lock(F_SETLK, F_UNLCK, tests[index][OFFSET], tests[index][LENGTH]);
983                             break;
984                         case F_CLOSE:
985                             result = do_close();
986                             break;
987                         case F_OPEN:
988                             result = do_open(tests[index][FLAGS]);
989                             break;
990                         case WRTEST:
991                             result = do_lock(F_GETLK, F_WRLCK, tests[index][OFFSET], tests[index][LENGTH]);
992                             break;
993                         case RDTEST:
994                             result = do_lock(F_GETLK, F_RDLCK, tests[index][OFFSET], tests[index][LENGTH]);
995                             break;
996                     }
997                     if( result != tests[index][RESULT]) {
998                         fail_flag++;
999                         /* We have a failure */
1000                         if(debug)
1001                             fprintf(stderr, "Server failure in test %d, while %sing using offset %lld, length %lld - err = %d:%s\n", 
1002                                         ctl.test, tests[index][COMMAND]==WRLOCK?"write lock":
1003                                                 tests[index][COMMAND]==RDLOCK?"read lock":
1004                                                 tests[index][COMMAND]==UNLOCK?"unlock":
1005                                                 tests[index][COMMAND]==F_OPEN?"open":"clos", 
1006                                                 (long long)tests[index][OFFSET],
1007                                                 (long long)tests[index][LENGTH],
1008                                                 saved_errno, strerror(saved_errno));
1009                         fprintf(stderr, "Server failure in %lld:%s\n",
1010                                         (long long)tests[index][TEST_NUM],
1011                                         descriptions[tests[index][TEST_NUM] - 1]);
1012                     }
1013                 }
1014             /* else send it off to the client */
1015             } else if (tests[index][WHO] == CLIENT) {
1016                 if(tests[index][TEST_NUM] == 0) {
1017                     ctl.test = 0;
1018                     end=1;
1019                 } 
1020                 if(debug > 1)
1021                     fprintf(stderr, "Sending command to client (%d) - %s - %lld:%lld\n", 
1022                                         index, tests[index][COMMAND]==WRLOCK?"write lock":
1023                                         tests[index][COMMAND]==RDLOCK?"read lock":
1024                                         tests[index][COMMAND]==UNLOCK?"unlock": 
1025                                         tests[index][COMMAND]==F_OPEN?"open":"clos", 
1026                                         (long long)tests[index][OFFSET],
1027                                         (long long)tests[index][LENGTH]);
1028                 /* get the client to do something */
1029                 ctl.index = index;
1030                 send_ctl();
1031                 if(ctl.test != 0) {
1032                     /* Get the clients response */
1033                     recv_ctl();
1034                     /* this is the whether the test passed or failed,
1035                      * not what the command returned */
1036                     if( ctl.result == FAIL ) {
1037                         fail_flag++;
1038                         if(debug)
1039                             fprintf(stderr, "Client failure in test %d, while %sing using offset %lld, length %lld - err = %d:%s\n",
1040                                         ctl.test, ctl.command==WRLOCK?"write lock":
1041                                         ctl.command==RDLOCK?"read lock":
1042                                         ctl.command==UNLOCK?"unlock":
1043                                         ctl.command==F_OPEN?"open":"clos",
1044                                         (long long)ctl.offset, (long long)ctl.length,
1045                                         ctl.error, strerror(ctl.error));
1046                         fprintf(stderr, "Client failure in %lld:%s\n",
1047                                         (long long)tests[index][TEST_NUM],
1048                                         descriptions[tests[index][TEST_NUM] - 1]);
1049                     }
1050                 }
1051             }
1052             if (debug > 1) {
1053                 fprintf(stderr, "server sleeping ...\n");
1054                 SLEEP(1);
1055             }
1056             if(tests[index][TEST_NUM] != 0) {
1057                 if(last_test != tests[index][TEST_NUM]) {
1058                     test_count++;
1059                     if(fail_flag)
1060                         fail_count++;
1061                     fail_flag = 0;
1062
1063                 }
1064                 last_test = tests[index][TEST_NUM];
1065             }
1066                 
1067             index++;
1068         } else { /* CLIENT */
1069             if(debug > 2)
1070                 fprintf(stderr,"client: waiting...\n");
1071             /* wait for the server to do something */
1072             recv_ctl();
1073
1074             /* check for a client command */
1075             index = ctl.index;
1076             if (tests[index][WHO] != CLIENT) { 
1077                 fprintf(stderr, "not a client command index (%d)\n", index);
1078                 exit(1);
1079             }
1080                 
1081             if(ctl.test == 0) {
1082                 end = 1;
1083                 break;
1084             }
1085                 
1086
1087             ctl.command = tests[index][COMMAND];
1088             ctl.offset = tests[index][OFFSET];
1089             ctl.length = tests[index][LENGTH];
1090             switch(tests[index][COMMAND]) {
1091                 case WRLOCK:
1092                     result = do_lock(F_SETLK, F_WRLCK, tests[index][OFFSET], tests[index][LENGTH]);
1093                     break;
1094                 case RDLOCK:
1095                     result = do_lock(F_SETLK, F_RDLCK, tests[index][OFFSET], tests[index][LENGTH]);
1096                     break;
1097                 case UNLOCK:
1098                     result = do_lock(F_SETLK, F_UNLCK, tests[index][OFFSET], tests[index][LENGTH]);
1099                     break;
1100                 case F_CLOSE:
1101                     result = do_close();
1102                     break;
1103                 case F_OPEN:
1104                     result = do_open(tests[index][FLAGS]);
1105                     break;
1106                 case WRTEST:
1107                     result = do_lock(F_GETLK, F_WRLCK, tests[index][OFFSET], tests[index][LENGTH]);
1108                     break;
1109                 case RDTEST:
1110                     result = do_lock(F_GETLK, F_RDLCK, tests[index][OFFSET], tests[index][LENGTH]);
1111                     break;
1112             }
1113             if( result != tests[index][RESULT] ) {
1114                 if(debug)
1115                     fprintf(stderr,"Got %d, wanted %lld\n", result,
1116                                         (long long)tests[index][RESULT]);
1117                 ctl.result = FAIL;
1118                 ctl.error = saved_errno;
1119                 fail_count++;
1120             } else {
1121                 ctl.result = PASS;
1122             }
1123             if(debug > 2)
1124                 fprintf(stderr,"client: sending result to server (%d)\n", ctl.index);
1125             /* Send result to the server */
1126             send_ctl();
1127             if(tests[index][TEST_NUM] != 0) {
1128                 if(last_test != tests[index][TEST_NUM])
1129                     test_count++;
1130                 last_test = tests[index][TEST_NUM];
1131             }
1132         }
1133     }
1134     if(server)
1135         printf("%d tests run, %d failed\n", test_count, fail_count);
1136 }   
1137     if (buf) {
1138         free(buf);
1139     }
1140
1141     
1142     exit(fail_count);
1143     /*NOTREACHED*/
1144 }
1145
1146