Linux/Android: Refactor MessageQ_create to Register Later with NameServer
[ipc/ipcdev.git] / linux / src / api / NameServer.c
1 /*
2  * Copyright (c) 2012-2015 Texas Instruments Incorporated - http://www.ti.com
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * *  Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  *
12  * *  Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * *  Neither the name of Texas Instruments Incorporated nor the names of
17  *    its contributors may be used to endorse or promote products derived
18  *    from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32 /*
33  *  ======== NameServer_client.c ========
34  */
35 #include <ti/ipc/Std.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <errno.h>
41 #include <sys/stat.h>
42 #include <sys/types.h>
43 #include <unistd.h>
44 #include <time.h>
45 #include <pthread.h>
47 #include <ti/ipc/NameServer.h>
49 #include <ladclient.h>
50 #include <_lad.h>
52 /* traces in this file are controlled via _NameServer_verbose */
53 Bool _NameServer_verbose = FALSE;
54 #define verbose _NameServer_verbose
56 /*
57  * The NameServer_*() APIs are reproduced here.  These versions are just
58  * front-ends for communicating with the actual NameServer module (currently
59  * implemented as a daemon process ala LAD).
60  */
62 Int NameServer_setup(Void)
63 {
64     Int status;
65     LAD_ClientHandle handle;
66     struct LAD_CommandObj cmd;
67     union LAD_ResponseObj rsp;
69     handle = LAD_findHandle();
70     if (handle == LAD_MAXNUMCLIENTS) {
71         PRINTVERBOSE1(
72           "NameServer_setup: can't find connection to daemon for pid %d\n",
73            getpid())
75         return NameServer_E_RESOURCE;
76     }
78     cmd.cmd = LAD_NAMESERVER_SETUP;
79     cmd.clientId = handle;
81     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
82         PRINTVERBOSE1(
83           "NameServer_setup: sending LAD command failed, status=%d\n", status)
84         return NameServer_E_FAIL;
85     }
87     if ((status = LAD_getResponse(handle, &rsp)) != LAD_SUCCESS) {
88         PRINTVERBOSE1("NameServer_setup: no LAD response, status=%d\n", status)
89         return(status);
90     }
91     status = rsp.status;
93     PRINTVERBOSE2(
94       "NameServer_setup: got LAD response for client %d, status=%d\n",
95       handle, status)
97     return status;
98 }
100 Int NameServer_destroy(Void)
102     Int status;
103     LAD_ClientHandle handle;
104     struct LAD_CommandObj cmd;
105     union LAD_ResponseObj rsp;
107     PRINTVERBOSE0("NameServer_destroy: entered\n")
109     handle = LAD_findHandle();
110     if (handle == LAD_MAXNUMCLIENTS) {
111         PRINTVERBOSE1(
112           "NameServer_destroy: can't find connection to daemon for pid %d\n",
113           getpid())
115         return NameServer_E_RESOURCE;
116     }
118     cmd.cmd = LAD_NAMESERVER_DESTROY;
119     cmd.clientId = handle;
121     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
122         PRINTVERBOSE1(
123           "NameServer_destroy: sending LAD command failed, status=%d\n", status)
124         return NameServer_E_FAIL;
125     }
127     if ((status = LAD_getResponse(handle, &rsp)) != LAD_SUCCESS) {
128         PRINTVERBOSE1(
129           "NameServer_destroy: no LAD response, status=%d\n", status)
130         return(status);
131     }
132     status = rsp.status;
134     PRINTVERBOSE2(
135      "NameServer_destroy: got LAD response for client %d, status=%d\n",
136      handle, status)
138     return status;
141 Void NameServer_Params_init(NameServer_Params *params)
143     Int status;
144     LAD_ClientHandle handle;
145     struct LAD_CommandObj cmd;
146     union LAD_ResponseObj rsp;
148     handle = LAD_findHandle();
149     if (handle == LAD_MAXNUMCLIENTS) {
150         PRINTVERBOSE1(
151          "NameServer_Params_init: can't find connection to daemon for pid %d\n",
152          getpid())
154         return;
155     }
157     cmd.cmd = LAD_NAMESERVER_PARAMS_INIT;
158     cmd.clientId = handle;
160     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
161         PRINTVERBOSE1(
162           "NameServer_Params_init: sending LAD command failed, status=%d\n",
163           status)
164         return;
165     }
167     if ((status = LAD_getResponse(handle, &rsp)) != LAD_SUCCESS) {
168         PRINTVERBOSE1(
169           "NameServer_Params_init: no LAD response, status=%d\n", status)
170         return;
171     }
173     PRINTVERBOSE1("NameServer_Params_init: got LAD response for client %d\n",
174                   handle)
176     memcpy(params, &rsp.params, sizeof(NameServer_Params));
178     return;
181 NameServer_Handle NameServer_create(String name,
182                                     const NameServer_Params *params)
184     Int status;
185     LAD_ClientHandle handle;
186     struct LAD_CommandObj cmd;
187     union LAD_ResponseObj rsp;
189     handle = LAD_findHandle();
190     if (handle == LAD_MAXNUMCLIENTS) {
191         PRINTVERBOSE1(
192           "NameServer_create: can't find connection to daemon for pid %d\n",
193           getpid())
195         return NULL;
196     }
198     cmd.cmd = LAD_NAMESERVER_CREATE;
199     cmd.clientId = handle;
200     strncpy(cmd.args.create.name, name, NameServer_Params_MAXNAMELEN);
201     memcpy(&cmd.args.create.params, params, sizeof(NameServer_Params));
203     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
204         PRINTVERBOSE1(
205           "NameServer_create: sending LAD command failed, status=%d\n",
206           status)
207         return NULL;
208     }
210     if ((status = LAD_getResponse(handle, &rsp)) != LAD_SUCCESS) {
211         PRINTVERBOSE1("NameServer_create: no LAD response, status=%d\n", status)
212         return NULL;
213     }
215     PRINTVERBOSE1("NameServer_create: got LAD response for client %d\n", handle)
217     return rsp.handle;
220 Ptr NameServer_add(NameServer_Handle nsHandle, String name, Ptr buf,
221                    UInt32 len)
223     Int status;
224     LAD_ClientHandle clHandle;
225     struct LAD_CommandObj cmd;
226     union LAD_ResponseObj rsp;
228     clHandle = LAD_findHandle();
229     if (clHandle == LAD_MAXNUMCLIENTS) {
230         PRINTVERBOSE1(
231           "NameServer_add: can't find connection to daemon for pid %d\n",
232           getpid())
234         return NULL;
235     }
237     cmd.cmd = LAD_NAMESERVER_ADD;
238     cmd.clientId = clHandle;
239     cmd.args.add.handle = nsHandle;
240     strncpy(cmd.args.add.name, name, LAD_MAXENTRYNAMELEN);
241     cmd.args.add.len = len;
243     if (buf != NULL) {
244         memcpy(cmd.args.add.buf, buf, len);
245     }
247     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
248         PRINTVERBOSE1(
249           "NameServer_add: sending LAD command failed, status=%d\n",
250           status)
251         return NULL;
252     }
254     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
255         PRINTVERBOSE1(
256            "NameServer_add: no LAD response, status=%d\n", status)
257         return NULL;
258     }
260     PRINTVERBOSE1(
261        "NameServer_add: got LAD response for client %d\n", clHandle)
263     return rsp.entryPtr;
266 Int NameServer_get(NameServer_Handle nsHandle, String name, Ptr buf,
267                    UInt32 * len, UInt16 procId[])
269     Int status;
270     LAD_ClientHandle clHandle;
271     struct LAD_CommandObj cmd;
272     union LAD_ResponseObj rsp;
274     clHandle = LAD_findHandle();
275     if (clHandle == LAD_MAXNUMCLIENTS) {
276         PRINTVERBOSE1(
277           "NameServer_get: can't find connection to daemon for pid %d\n",
278            getpid())
280         return NameServer_E_RESOURCE;
281     }
283     cmd.cmd = LAD_NAMESERVER_GET;
284     cmd.clientId = clHandle;
285     cmd.args.get.handle = nsHandle;
286     strncpy(cmd.args.get.name, name, LAD_MAXENTRYNAMELEN);
287     if (procId != NULL) {
288         memcpy(cmd.args.get.procId, procId,
289                sizeof(UInt16) * MultiProc_MAXPROCESSORS);
290     }
291     else {
292         cmd.args.get.procId[0] = (UInt16)-1;
293     }
295     cmd.args.get.len = *len;
297     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
298         PRINTVERBOSE1(
299            "NameServer_get: sending LAD command failed, status=%d\n",
300             status)
301         return NameServer_E_FAIL;
302     }
304     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
305         PRINTVERBOSE1("NameServer_get: no LAD response, status=%d\n",
306                        status)
307         return NameServer_E_FAIL;
308     }
310     *len = rsp.get.len;
311     memcpy(buf, rsp.get.buf, *len);
313     status = rsp.get.status;
315     PRINTVERBOSE1("NameServer_get: got LAD response for client %d\n",
316                    clHandle)
318     return status;
321 Ptr NameServer_addUInt32(NameServer_Handle nsHandle, String name, UInt32 value)
323     Int status;
324     LAD_ClientHandle clHandle;
325     struct LAD_CommandObj cmd;
326     union LAD_ResponseObj rsp;
328     clHandle = LAD_findHandle();
329     if (clHandle == LAD_MAXNUMCLIENTS) {
330         PRINTVERBOSE1(
331           "NameServer_addUInt32: can't find connection to daemon for pid %d\n",
332           getpid())
334         return NULL;
335     }
337     cmd.cmd = LAD_NAMESERVER_ADDUINT32;
338     cmd.clientId = clHandle;
339     cmd.args.addUInt32.handle = nsHandle;
340     strncpy(cmd.args.addUInt32.name, name, LAD_MAXENTRYNAMELEN);
341     cmd.args.addUInt32.val = value;
343     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
344         PRINTVERBOSE1(
345           "NameServer_addUInt32: sending LAD command failed, status=%d\n",
346           status)
347         return NULL;
348     }
350     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
351         PRINTVERBOSE1(
352            "NameServer_addUInt32: no LAD response, status=%d\n", status)
353         return NULL;
354     }
356     PRINTVERBOSE1(
357        "NameServer_addUInt32: got LAD response for client %d\n", clHandle)
359     return rsp.entryPtr;
362 Int NameServer_getUInt32(NameServer_Handle nsHandle, String name, Ptr buf,
363                           UInt16 procId[])
365     Int status;
366     LAD_ClientHandle clHandle;
367     UInt32 *val;
368     struct LAD_CommandObj cmd;
369     union LAD_ResponseObj rsp;
371     clHandle = LAD_findHandle();
372     if (clHandle == LAD_MAXNUMCLIENTS) {
373         PRINTVERBOSE1(
374           "NameServer_getUInt32: can't find connection to daemon for pid %d\n",
375            getpid())
377         return NameServer_E_RESOURCE;
378     }
380     cmd.cmd = LAD_NAMESERVER_GETUINT32;
381     cmd.clientId = clHandle;
382     cmd.args.getUInt32.handle = nsHandle;
383     strncpy(cmd.args.getUInt32.name, name, LAD_MAXENTRYNAMELEN);
384     if (procId != NULL) {
385         memcpy(cmd.args.getUInt32.procId, procId,
386                sizeof(UInt16) * MultiProc_MAXPROCESSORS);
387     }
388     else {
389         cmd.args.getUInt32.procId[0] = (UInt16)-1;
390     }
392     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
393         PRINTVERBOSE1(
394            "NameServer_getUInt32: sending LAD command failed, status=%d\n",
395             status)
396         return NameServer_E_FAIL;
397     }
399     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
400         PRINTVERBOSE1("NameServer_getUInt32: no LAD response, status=%d\n",
401                        status)
402         return NameServer_E_FAIL;
403     }
405     val = (UInt32 *)buf;
406     *val = rsp.getUInt32.val;
407     status = rsp.getUInt32.status;
409     PRINTVERBOSE1("NameServer_getUInt32: got LAD response for client %d\n",
410                    clHandle)
412     return status;
415 /*
416  *  ======== NameServer_getLocal ========
417  */
418 Int NameServer_getLocal(NameServer_Handle ns, String name, Ptr buf, UInt32 *len)
420     Int status;
421     LAD_ClientHandle clHandle;
422     struct LAD_CommandObj cmd;
423     union LAD_ResponseObj rsp;
425     clHandle = LAD_findHandle();
427     if (clHandle == LAD_MAXNUMCLIENTS) {
428         PRINTVERBOSE0("NameServer_getLocal: not connected to LAD\n");
429         return (NameServer_E_RESOURCE);
430     }
432     cmd.cmd = LAD_NAMESERVER_GETLOCAL;
433     cmd.clientId = clHandle;
434     cmd.args.getLocal.handle = ns;
435     strncpy(cmd.args.getLocal.name, name, LAD_MAXENTRYNAMELEN);
436     cmd.args.getLocal.len = *len;
438     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
439         PRINTVERBOSE1("NameServer_getLocal: sending LAD command failed, "
440                 "status=%d\n", status)
441         return (NameServer_E_FAIL);
442     }
444     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
445         PRINTVERBOSE1("NameServer_getLocal: no LAD response, status=%d\n",
446                 status)
447         return (NameServer_E_FAIL);
448     }
450     *len = rsp.get.len;
451     memcpy(buf, rsp.get.buf, *len);
453     status = rsp.get.status;
455     PRINTVERBOSE1("NameServer_getLocal: LAD response, status=%d\n", status)
456     return (status);
459 /*
460  *  ======== NameServer_getLocalUInt32 ========
461  */
462 Int NameServer_getLocalUInt32(NameServer_Handle ns, String name, Ptr buf)
464     Int status;
465     LAD_ClientHandle clHandle;
466     UInt32 *val;
467     struct LAD_CommandObj cmd;
468     union LAD_ResponseObj rsp;
470     clHandle = LAD_findHandle();
472     if (clHandle == LAD_MAXNUMCLIENTS) {
473         PRINTVERBOSE0("NameServer_getLocalUInt32: not connected to LAD\n");
474         return (NameServer_E_RESOURCE);
475     }
477     cmd.cmd = LAD_NAMESERVER_GETLOCALUINT32;
478     cmd.clientId = clHandle;
479     cmd.args.getLocalUInt32.handle = ns;
480     strncpy(cmd.args.getLocalUInt32.name, name, LAD_MAXENTRYNAMELEN);
482     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
483         PRINTVERBOSE1("NameServer_getLocalUInt32: sending LAD command failed, "
484                 "status=%d\n", status)
485         return (NameServer_E_FAIL);
486     }
488     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
489         PRINTVERBOSE1("NameServer_getLocalUInt32: no LAD response, status=%d\n",
490                 status)
491         return (NameServer_E_FAIL);
492     }
494     val = (UInt32 *)buf;
495     *val = rsp.getUInt32.val;
496     status = rsp.getUInt32.status;
498     PRINTVERBOSE1("NameServer_getLocalUInt32: LAD response, status=%d\n",
499             status)
500     return (status);
503 Int NameServer_remove(NameServer_Handle nsHandle, String name)
505     Int status;
506     LAD_ClientHandle clHandle;
507     struct LAD_CommandObj cmd;
508     union LAD_ResponseObj rsp;
510     clHandle = LAD_findHandle();
511     if (clHandle == LAD_MAXNUMCLIENTS) {
512         PRINTVERBOSE1(
513          "NameServer_remove: can't find connection to daemon for pid %d\n",
514          getpid())
516         return NameServer_E_RESOURCE;
517     }
519     cmd.cmd = LAD_NAMESERVER_REMOVE;
520     cmd.clientId = clHandle;
521     cmd.args.remove.handle = nsHandle;
522     strncpy(cmd.args.remove.name, name, LAD_MAXENTRYNAMELEN);
524     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
525         PRINTVERBOSE1(
526          "NameServer_remove: sending LAD command failed, status=%d\n",
527          status)
528         return NameServer_E_FAIL;
529     }
531     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
532         PRINTVERBOSE1("NameServer_remove: no LAD response, status=%d\n", status)
533         return NameServer_E_FAIL;
534     }
536     status = rsp.status;
538     PRINTVERBOSE1("NameServer_remove: got LAD response for client %d\n",
539                    clHandle)
541     return status;
544 Int NameServer_removeEntry(NameServer_Handle nsHandle, Ptr entry)
546     Int status;
547     LAD_ClientHandle clHandle;
548     struct LAD_CommandObj cmd;
549     union LAD_ResponseObj rsp;
551     clHandle = LAD_findHandle();
552     if (clHandle == LAD_MAXNUMCLIENTS) {
553         PRINTVERBOSE1(
554          "NameServer_removeEntry: can't find connection to daemon for pid %d\n",
555          getpid())
557         return NameServer_E_RESOURCE;
558     }
560     cmd.cmd = LAD_NAMESERVER_REMOVEENTRY;
561     cmd.clientId = clHandle;
562     cmd.args.removeEntry.handle = nsHandle;
563     cmd.args.removeEntry.entryPtr = entry;
565     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
566         PRINTVERBOSE1(
567           "NameServer_removeEntry: sending LAD command failed, status=%d\n",
568           status)
569         return NameServer_E_FAIL;
570     }
572     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
573         PRINTVERBOSE1("NameServer_removeEntry: no LAD response, status=%d\n",
574                        status)
575         return NameServer_E_FAIL;
576     }
578     status = rsp.status;
580     PRINTVERBOSE1("NameServer_removeEntry: got LAD response for client %d\n",
581                    clHandle)
583     return status;
586 Int NameServer_delete(NameServer_Handle *nsHandle)
588     Int status;
589     LAD_ClientHandle clHandle;
590     struct LAD_CommandObj cmd;
591     union LAD_ResponseObj rsp;
593     clHandle = LAD_findHandle();
594     if (clHandle == LAD_MAXNUMCLIENTS) {
595         PRINTVERBOSE1(
596           "NameServer_delete: can't find connection to daemon for pid %d\n",
597           getpid())
599         return NameServer_E_RESOURCE;
600     }
602     cmd.cmd = LAD_NAMESERVER_DELETE;
603     cmd.clientId = clHandle;
604     cmd.args.nsdelete.handle = *nsHandle;
606     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
607         PRINTVERBOSE1(
608           "NameServer_delete: sending LAD command failed, status=%d\n",
609           status)
610         return NameServer_E_FAIL;
611     }
613     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
614         PRINTVERBOSE1("NameServer_delete: no LAD response, status=%d\n", status)
615         return NameServer_E_FAIL;
616     }
618     *nsHandle = rsp.nsdelete.handle;
619     status = rsp.nsdelete.status;
621     PRINTVERBOSE1("NameServer_delete: got LAD response for client %d\n",
622                    clHandle)
624     return status;
627 /*
628  *  ======== NameServer_attach ========
629  *  Internal function.
630  */
631 Int NameServer_attach(UInt16 procId)
633     Int status;
634     LAD_ClientHandle clHandle;
635     struct LAD_CommandObj cmd;
636     union LAD_ResponseObj rsp;
638     clHandle = LAD_findHandle();
640     if (clHandle == LAD_MAXNUMCLIENTS) {
641         PRINTVERBOSE0("NameServer_attach: not connected to LAD\n");
642         return (NameServer_E_RESOURCE);
643     }
645     cmd.cmd = LAD_NAMESERVER_ATTACH;
646     cmd.clientId = clHandle;
647     cmd.args.attach.procId = procId;
649     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
650         PRINTVERBOSE1("NameServer_attach: sending LAD command failed, "
651                 "status=%d\n", status);
652         return (NameServer_E_FAIL);
653     }
655     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
656         PRINTVERBOSE1("NameServer_attach: no LAD response, status=%d\n",
657                 status);
658         return (NameServer_E_FAIL);
659     }
661     status = rsp.status;
662     PRINTVERBOSE1("NameServer_attach: LAD response, status=%d\n", status)
663     return (status);
666 /*
667  *  ======== NameServer_detach ========
668  *  Internal function.
669  */
670 Int NameServer_detach(UInt16 procId)
672     Int status;
673     LAD_ClientHandle clHandle;
674     struct LAD_CommandObj cmd;
675     union LAD_ResponseObj rsp;
677     clHandle = LAD_findHandle();
679     if (clHandle == LAD_MAXNUMCLIENTS) {
680         PRINTVERBOSE0("NameServer_detach: not connected to LAD\n");
681         return (NameServer_E_RESOURCE);
682     }
684     cmd.cmd = LAD_NAMESERVER_DETACH;
685     cmd.clientId = clHandle;
686     cmd.args.detach.procId = procId;
688     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
689         PRINTVERBOSE1("NameServer_detach: sending LAD command failed, "
690                 "status=%d\n", status);
691         return (NameServer_E_FAIL);
692     }
694     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
695         PRINTVERBOSE1("NameServer_detach: no LAD response, status=%d\n",
696                 status);
697         return (NameServer_E_FAIL);
698     }
700     status = rsp.status;
701     PRINTVERBOSE1("NameServer_detach: LAD response, status=%d\n", status)
702     return (status);