check_type: fix incorrect documentation.
[ccan] / ccan / nfs / mount.c
1 /*
2    Copyright (C) by Ronnie Sahlberg <ronniesahlberg@gmail.com> 2010
3    
4    This program is free software; you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation; either version 3 of the License, or
7    (at your option) any later version.
8    
9    This program is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12    GNU General Public License for more details.
13    
14    You should have received a copy of the GNU General Public License
15    along with this program; if not, see <http://www.gnu.org/licenses/>.
16 */
17
18 #include <stdio.h>
19 #include <errno.h>
20 #include <rpc/xdr.h>
21 #include "nfs.h"
22 #include "libnfs-raw.h"
23 #include "libnfs-private.h"
24 #include "rpc/mount.h"
25
26
27 int rpc_mount_null_async(struct rpc_context *rpc, rpc_cb cb, void *private_data)
28 {
29         struct rpc_pdu *pdu;
30
31         pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_NULL, cb, private_data, (xdrproc_t)xdr_void, 0);
32         if (pdu == NULL) {
33                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for mount/null call");
34                 return -1;
35         }
36
37         if (rpc_queue_pdu(rpc, pdu) != 0) {
38                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for mount/null call");
39                 rpc_free_pdu(rpc, pdu);
40                 return -2;
41         }
42
43         return 0;
44 }
45
46 int rpc_mount_mnt_async(struct rpc_context *rpc, rpc_cb cb, char *export, void *private_data)
47 {
48         struct rpc_pdu *pdu;
49
50         pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_MNT, cb, private_data, (xdrproc_t)xdr_mountres3, sizeof(mountres3));
51         if (pdu == NULL) {
52                 rpc_set_error(rpc, "Out of memory. Failed to allocate pdu for mount/mnt call");
53                 return -1;
54         }
55
56         if (xdr_dirpath(&pdu->xdr, &export) == 0) {
57                 rpc_set_error(rpc, "XDR error. Failed to encode mount/mnt call");
58                 rpc_free_pdu(rpc, pdu);
59                 return -2;
60         }
61
62         if (rpc_queue_pdu(rpc, pdu) != 0) {
63                 rpc_set_error(rpc, "Out of memory. Failed to queue pdu for mount/mnt call");
64                 rpc_free_pdu(rpc, pdu);
65                 return -2;
66         }
67
68         return 0;
69 }
70
71 int rpc_mount_dump_async(struct rpc_context *rpc, rpc_cb cb, void *private_data)
72 {
73         struct rpc_pdu *pdu;
74
75         pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_DUMP, cb, private_data, (xdrproc_t)xdr_mountlist, sizeof(mountlist));
76         if (pdu == NULL) {
77                 printf("Failed to allocate pdu for mount/dump\n");
78                 return -1;
79         }
80
81         if (rpc_queue_pdu(rpc, pdu) != 0) {
82                 printf("Failed to queue mount/dump pdu\n");
83                 rpc_free_pdu(rpc, pdu);
84                 return -2;
85         }
86
87         return 0;
88 }
89
90 int rpc_mount_umnt_async(struct rpc_context *rpc, rpc_cb cb, char *export, void *private_data)
91 {
92         struct rpc_pdu *pdu;
93
94         pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_UMNT, cb, private_data, (xdrproc_t)xdr_void, 0);
95         if (pdu == NULL) {
96                 printf("Failed to allocate pdu for mount/umnt\n");
97                 return -1;
98         }
99
100         if (xdr_dirpath(&pdu->xdr, &export) == 0) {
101                 printf("failed to encode dirpath for mount/umnt\n");
102                 rpc_free_pdu(rpc, pdu);
103                 return -2;
104         }
105
106         if (rpc_queue_pdu(rpc, pdu) != 0) {
107                 printf("Failed to queue mount/umnt pdu\n");
108                 rpc_free_pdu(rpc, pdu);
109                 return -2;
110         }
111
112         return 0;
113 }
114
115 int rpc_mount_umntall_async(struct rpc_context *rpc, rpc_cb cb, void *private_data)
116 {
117         struct rpc_pdu *pdu;
118
119         pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_UMNTALL, cb, private_data, (xdrproc_t)xdr_void, 0);
120         if (pdu == NULL) {
121                 printf("Failed to allocate pdu for mount/umntall\n");
122                 return -1;
123         }
124
125         if (rpc_queue_pdu(rpc, pdu) != 0) {
126                 printf("Failed to queue mount/umntall pdu\n");
127                 rpc_free_pdu(rpc, pdu);
128                 return -2;
129         }
130
131         return 0;
132 }
133
134 int rpc_mount_export_async(struct rpc_context *rpc, rpc_cb cb, void *private_data)
135 {
136         struct rpc_pdu *pdu;
137
138         pdu = rpc_allocate_pdu(rpc, MOUNT_PROGRAM, MOUNT_V3, MOUNT3_EXPORT, cb, private_data, (xdrproc_t)xdr_exports, sizeof(exports));
139         if (pdu == NULL) {
140                 printf("Failed to allocate pdu for mount/export\n");
141                 return -1;
142         }
143
144         if (rpc_queue_pdu(rpc, pdu) != 0) {
145                 printf("Failed to queue mount/export pdu\n");
146                 rpc_free_pdu(rpc, pdu);
147                 return -2;
148         }
149
150         return 0;
151 }
152
153 char *mountstat3_to_str(int st)
154 {
155         enum mountstat3 stat = st;
156
157         char *str = "unknown mount stat";
158         switch (stat) {
159         case MNT3_OK:             str="MNT3_OK"; break;
160         case MNT3ERR_PERM:        str="MNT3ERR_PERM"; break;
161         case MNT3ERR_NOENT:       str="MNT3ERR_NOENT"; break;
162         case MNT3ERR_IO:          str="MNT3ERR_IO"; break;
163         case MNT3ERR_ACCES:       str="MNT3ERR_ACCES"; break;
164         case MNT3ERR_NOTDIR:      str="MNT3ERR_NOTDIR"; break;
165         case MNT3ERR_INVAL:       str="MNT3ERR_INVAL"; break;
166         case MNT3ERR_NAMETOOLONG: str="MNT3ERR_NAMETOOLONG"; break;
167         case MNT3ERR_NOTSUPP:     str="MNT3ERR_NOTSUPP"; break;
168         case MNT3ERR_SERVERFAULT: str="MNT3ERR_SERVERFAULT"; break;
169         }
170         return str;
171 }
172
173
174 int mountstat3_to_errno(int st)
175 {
176         enum mountstat3 stat = st;
177
178         switch (stat) {
179         case MNT3_OK:             return 0; break;
180         case MNT3ERR_PERM:        return -EPERM; break;
181         case MNT3ERR_NOENT:       return -EPERM; break;
182         case MNT3ERR_IO:          return -EIO; break;
183         case MNT3ERR_ACCES:       return -EACCES; break;
184         case MNT3ERR_NOTDIR:      return -ENOTDIR; break;
185         case MNT3ERR_INVAL:       return -EINVAL; break;
186         case MNT3ERR_NAMETOOLONG: return -E2BIG; break;
187         case MNT3ERR_NOTSUPP:     return -EINVAL; break;
188         case MNT3ERR_SERVERFAULT: return -EIO; break;
189         }
190         return -ERANGE;
191 }