@cetapod/react-native-smb 1.0.0

package/docs/API.md

@@ -0,0 +1,105 @@
+# API reference
+
+All async methods return `SmbTask<T>`. Await with `.result()`. See [Task model](./TASK_MODEL.md) for subscribe, cancel, and hook patterns.
+
+## Connection
+
+| Method | Returns | `result()` type | Notes |
+| ------ | ------- | --------------- | ----- |
+| `initialize(url, creds)` | `SmbTask<void>` | `void` | Server only, no share |
+| `connect(url, creds)` | `SmbTask<SmbConnectionInfo>` | `SmbConnectionInfo` | Auth + mount share from URL |
+| `connectShare(share)` | `SmbTask<SmbConnectionInfo>` | `SmbConnectionInfo` | Switch share |
+| `disconnect()` | `SmbTask<void>` | `void` | Close session |
+| `listShares()` | `SmbTask<SmbShareList[]>` | `SmbShareList[]` | Enumerate shares |
+| `isConnected()` | `boolean` | — | Sync |
+| `isInitialized()` | `boolean` | — | Sync |
+
+URL: `smb://[<domain;][<username>@]<host>[:<port>]/<share>/<path>`
+
+```typescript
+interface SmbCredentials { username: string; password: string; }
+
+interface SmbConnectionInfo {
+  url: string; server: string; share: string; isConnected: boolean;
+}
+
+interface SmbShareList { name: string; comment: string; }
+```
+
+## File system
+
+| Method | Returns | `result()` type | Notes |
+| ------ | ------- | --------------- | ----- |
+| `listDirectory(path, recursive?, maxDepth?)` | `SmbTask<SmbFileInfo[]>` | `SmbFileInfo[]` | `maxDepth: -1` = unlimited |
+| `getPathInfo(path)` | `SmbTask<SmbFileInfo>` | `SmbFileInfo` | |
+| `downloadFile(remote, local)` | `SmbTask<void>` | `void` | `subscribe()` for progress |
+| `uploadFile(local, remote)` | `SmbTask<void>` | `void` | `subscribe()` for progress |
+| `createDirectory(path)` | `SmbTask<void>` | `void` | Creates parents |
+| `deleteItem(path)` | `SmbTask<void>` | `void` | Recursive for dirs |
+| `renameItem(path, newName)` | `SmbTask<void>` | `void` | Basename only |
+| `moveItem(from, to)` | `SmbTask<void>` | `void` | |
+| `copyItem(from, to, recursive?)` | `SmbTask<void>` | `void` | |
+| `duplicateItem(path)` | `SmbTask<string>` | `string` | New path |
+| `getSecurityDescriptor(path)` | `SmbTask<SmbSecurityDescriptor>` | `SmbSecurityDescriptor` | |
+
+```typescript
+interface SmbFileInfo {
+  name: string; path: string; size: number; isDirectory: boolean;
+  modifiedAt: number; accessedAt: number; createdAt: number; changedAt: number;
+  childCount?: number; children?: SmbFileInfo[];
+}
+```
+
+## Pool
+
+| Method | Returns | Notes |
+| ------ | ------- | ----- |
+| `getPoolInfo()` | `PoolInfo` | Slot snapshot |
+| `subscribePoolInfo(cb)` | `string` | Listener ID |
+| `unsubscribePoolInfo(id)` | `void` | |
+| `resetPool()` | `void` | Disconnect all slots |
+| `dispose()` | `void` | Tear down transfer store |
+
+See [Connection pool](./ARCHITECTURE.md).
+
+## Types
+
+### `SmbTask<T>`
+
+| Member | Description |
+| ------ | ----------- |
+| `id` | Task identifier |
+| `progress`, `status` | Live getters after `subscribe()` |
+| `result()` | `Promise<T>` |
+| `subscribe(listener?)` | Returns unsubscribe |
+| `cancel()` | Abort |
+| `get()` | One-shot snapshot |
+| `SmbTask.settleAll(tasks)` | `Promise.allSettled` over results |
+
+### Errors
+
+`SmbTaskError` with `code: SmbError` and optional `taskId`.
+
+`SmbError`: `Unknown`, `Cancelled`, `InvalidArgument`, `NotFound`, `AlreadyExists`, `AccessDenied`, `NotDirectory`, `IsDirectory`, `DirectoryNotEmpty`, `NotConnected`, `ConnectionRefused`, `TimedOut`, `Busy`, `NoSpace`, `Io`.
+
+### Hooks
+
+| Hook | Purpose |
+| ---- | ------- |
+| `useSubscribe(task)` | React state for progress/status |
+| `useTransfers(smb)` | Active transfer tasks |
+| `useTransferActions(smb)` | `clearCompleted()`, `hide(taskId)` |
+
+## Utilities
+
+Path helpers:
+
+| Function | Description |
+| -------- | ----------- |
+| `normalizePath` | Forward slashes, trim trailing `/` |
+| `splitPath` | `{ parentDirectory, baseFileName, extension, fullFileName }` |
+| `joinPath`, `getParentPath`, `getFileName` | Path composition |
+| `generateCopyName` | `"file copy 2.pdf"` naming |
+| `formatFileSize`, `formatDate` | Display helpers |
+
+Label helpers: `statusLabel`, `operationLabel`, `isTransferKind`, `isDeterminateKind`, `isTerminalStatus`.

package/docs/ARCHITECTURE.md

@@ -0,0 +1,70 @@
+# Connection pool
+
+`HybridSMB` runs up to four SMB operations in parallel through a `SmbConnectionPool(4)`. Each slot is one `SmbConnectionManager` / `smb2_context` — its own TCP socket and session:
+
+```
+TCP → NEGOTIATE → SESSION SETUP → TREE CONNECT
+```
+
+Tasks call `requestContext(mode)`, hold a slot for the operator's lifetime, then release via `PoolContextHandle`. One operator per slot (mutex on the context). Work on different slots runs concurrently.
+
+From `SmbConnectionPool.hpp`:
+
+```
+slot[0]       — Interactive-only
+slot[1..N-1]  — General (any AcquireMode; Interactive may overflow here)
+```
+
+| Slot | Accepts | Typical work |
+| ---- | ------- | ------------ |
+| `slot[0]` | `Interactive` only | `listDirectory`, `getPathInfo`, rename, move |
+| `slot[1..3]` | Any | Download, upload, copy, delete; grows on demand |
+
+```cpp
+bool PoolSlot::accepts(AcquireMode mode) const {
+    if (index_ == 0) return mode == AcquireMode::Interactive;
+    return true;
+}
+```
+
+Metadata never uses slot 0. Interactive work can overflow to slots 1–3 when slot 0 is busy.
+
+### Acquire modes
+
+| Mode | Operators |
+| ---- | --------- |
+| `Interactive` | `getPathInfo`, shallow `listDirectory`, `moveItem`, `renameItem`, `createDirectory`, `getSecurityDescriptor`, `listShares` |
+| `Metadata` | `downloadFile`, `uploadFile`, `copyItem`, `duplicateItem`, `deleteItem`, recursive `listDirectory` |
+
+FIFO queue per mode.
+
+The server sees each active slot as a separate client connection — multiple full sessions to the same host/share, not channels bound to one session. SMB3 multichannel is the protocol-level alternative: extra TCP links attach to an existing session via `SMB2_SESSION_FLAG_BINDING` and share one `SessionId`. libsmb2 does not implement that; each `smb2_context` maps to one `fd`, so the pool uses independent contexts instead.
+
+| | Pool | SMB3 multichannel |
+| --- | --- | --- |
+| Sessions | One per slot | One across channels |
+| Server view | N connections | 1 client, N channels |
+| Slot 0 reserved for UI | Yes | — |
+| Requires server multichannel cap | No | Yes |
+
+Slot 0 is application-level scheduling on top of what libsmb2 provides — interactive ops stay off the slots running bulk transfers.
+
+## Chunk pipeline
+
+Cross-task parallelism is the pool. Within a single transfer, `SmbFileIO` pipelines up to eight SMB2 READ/WRITE on the same `smb2_context` (`kMaxInFlight` in `SmbFileIO.cpp`). Same connection, same session — credit-based pipelining, separate from slot assignment.
+
+## Diagnostics
+
+```typescript
+const info = smb.getPoolInfo();
+const id = smb.subscribePoolInfo((snap) => console.log(snap));
+smb.unsubscribePoolInfo(id);
+```
+
+`PoolSlotInfo`: `index`, `interactiveOnly`, `state` (`Idle` | `Assigned` | `Activating`), `isConnected`, `shareName`, `taskId`, `kind`.
+
+- Same `index` turning over quickly → tasks queuing on one slot.
+- Slots 1–3 all `Assigned`, metadata still pending → pool full.
+- Interactive `kind` on slot 1–3 → slot 0 was busy.
+
+`example/components/PoolDebugPanel.js`

package/docs/TASK_MODEL.md

@@ -0,0 +1,149 @@
+# Task model
+
+Every SMB operation returns a `SmbTask<T>`. Creating the task starts native work immediately. Nothing is subscribed until you ask for it.
+
+You can mix three actions on any task:
+
+| Action | When | API |
+| ------ | ---- | --- |
+| Get result | You need the return value | `await task.result()` |
+| Watch progress | UI needs updates | `task.subscribe()` or `useSubscribe` |
+| Cancel | User aborts | `task.cancel()` |
+
+## Get the result
+
+```typescript
+import { SMB, type SmbCredentials } from '@cetapod/react-native-smb';
+
+const smb = SMB();
+const creds: SmbCredentials = { username: 'user', password: 'pass' };
+
+await smb.connect('smb://192.168.1.100/Share', creds).result();
+
+const files = await smb.listDirectory('/', false, -1).result();
+await smb.downloadFile('/doc.pdf', '/local/doc.pdf').result();
+```
+
+Hold the handle and await later:
+
+```typescript
+const task = smb.copyItem('/src', '/dst', true);
+await task.result();
+```
+
+Run several tasks and collect outcomes (like `Promise.allSettled`):
+
+```typescript
+import { SmbTask } from '@cetapod/react-native-smb';
+
+const tasks = files.map((f) => smb.deleteItem(f.path));
+const results = await SmbTask.settleAll(tasks);
+```
+
+## Watch progress
+
+Imperative:
+
+```typescript
+const task = smb.downloadFile(remote, local);
+
+const unsub = task.subscribe(); // live task.progress / task.status
+// or:
+const unsub2 = task.subscribe((snap) => {
+  console.log(snap.progress, snap.bytesPerSecond, snap.status);
+});
+
+task.cancel();
+unsub();
+```
+
+React — `useSubscribe` subscribes automatically on mount and unsubscribes on unmount / task change:
+
+```tsx
+import { useSubscribe, statusLabel } from '@cetapod/react-native-smb';
+
+function DownloadBar({ task }) {
+  const { progress, status, cancel } = useSubscribe(task);
+
+  return (
+    <>
+      <Text>{Math.round(progress * 100)}%</Text>
+      <Text>{statusLabel(status)}</Text>
+      <Button onPress={cancel} title="Cancel" />
+    </>
+  );
+}
+```
+
+`progress` and `status` on the task object are live getters. Don't destructure them at creation time — read them after subscribing (`task.subscribe()`), or use `useSubscribe`, which subscribes for you.
+
+### Snapshot fields
+
+`subscribe` and `get()` return `SmbTaskState`:
+
+| Field | Description |
+| ----- | ----------- |
+| `progress` | `0–1` (determinate for transfers) |
+| `status` | `TaskStatus` enum |
+| `bytesDone` / `totalBytes` | Raw byte counts |
+| `bytesPerSecond` / `etaSeconds` | Throughput estimate |
+| `determinate` | `true` for download/upload/copy |
+| `sourcePath` / `destinationPath` | Paths for transfer ops |
+| `errorCode` / `errorMessage` | Set on failure |
+
+## Fire-and-forget
+
+Start work without awaiting — useful for bulk ops with a transfer tray:
+
+```typescript
+files.forEach((f) => smb.downloadFile(f.remote, f.local));
+```
+
+Refresh when everything settles:
+
+```typescript
+const tasks = files.map((f) => smb.deleteItem(f.path));
+void SmbTask.settleAll(tasks).then(() => reload());
+```
+
+### Transfer tray hooks
+
+```typescript
+import { useTransfers, useTransferActions } from '@cetapod/react-native-smb';
+
+function TransferTray({ smb }) {
+  const tasks = useTransfers(smb);
+  const { clearCompleted, hide } = useTransferActions(smb);
+
+  // tasks is SmbTaskState[] — all active transfers in the client store
+}
+```
+
+The example app's `TransferTrayPanel` shows this pattern end-to-end.
+
+## Error handling
+
+```typescript
+import { SMB, SmbError, SmbTaskError } from '@cetapod/react-native-smb';
+
+try {
+  await smb.getPathInfo('/nonexistent').result();
+} catch (error) {
+  if (error instanceof SmbTaskError) {
+    if (error.code === SmbError.NotFound) { /* ... */ }
+    if (error.code === SmbError.AccessDenied) { /* ... */ }
+  }
+}
+```
+
+`SmbTaskError` carries `code` (`SmbError` enum) and optional `taskId`.
+
+## Lifecycle
+
+When you're done with a client instance (e.g. user logs out), call `dispose()` to stop the transfer store listener:
+
+```typescript
+smb.dispose();
+```
+
+Sync state checks (`isConnected`, `isInitialized`) are available anytime without a task.

package/ios/include/smb2/libsmb2-dcerpc-lsa.h

@@ -0,0 +1,172 @@
+/* -*-  mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil;  -*- */
+/*
+   Copyright (C) 2020 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published by
+   the Free Software Foundation; either version 2.1 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _LIBSMB2_DCERPC_LSA_H_
+#define _LIBSMB2_DCERPC_LSA_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define LSA_CLOSE          0x00
+#define LSA_OPENPOLICY2    0x2c
+#define LSA_LOOKUPSIDS2    0x39
+
+/* Access Mask. LSA specific flags. */
+#define POLICY_VIEW_LOCAL_INFORMATION    0x00000001
+#define POLICY_VIEW_AUDIT_INFORMATION    0x00000002
+#define POLICY_GET_PRIVATE_INFORMATION   0x00000004
+#define POLICY_TRUST_ADMIN               0x00000008
+#define POLICY_CREATE_ACCOUNT            0x00000010
+#define POLICY_CREATE_SECRET             0x00000020
+#define POLICY_CREATE_PRIVILEGE          0x00000040
+#define POLICY_SET_DEFAULT_QUOTA_LIMITS  0x00000080
+#define POLICY_SET_AUDIT_REQUIREMENTS    0x00000100
+#define POLICY_AUDIT_LOG_ADMIN           0x00000200
+#define POLICY_SERVER_ADMIN              0x00000400
+#define POLICY_LOOKUP_NAMES              0x00000800
+#define POLICY_NOTIFICATION              0x00001000
+
+extern unsigned char NT_SID_AUTHORITY[6];
+
+typedef struct RPC_SID {
+        uint8_t Revision;
+        uint8_t SubAuthorityCount;
+        uint8_t IdentifierAuthority[6];
+        uint32_t *SubAuthority;
+} RPC_SID, *PRPC_SID;
+
+typedef struct _LSAPR_TRANSLATED_NAME_EX {
+        uint32_t Use;
+        char *Name;
+        uint32_t DomainIndex;
+        uint32_t Flags;
+} LSAPR_TRANSLATED_NAME_EX, *PLSAPR_TRANSLATED_NAME_EX;
+
+typedef struct _LSAPR_TRANSLATED_NAMES_EX {
+        uint32_t Entries;
+        LSAPR_TRANSLATED_NAME_EX  *Names;
+} LSAPR_TRANSLATED_NAMES_EX, *PLSAPR_TRANSLATED_NAMES_EX;
+
+typedef struct _SID_ENUM_BUFFER {
+        uint32_t Entries;
+        PRPC_SID *SidInfo;
+} LSAPR_SID_ENUM_BUFFER, *PLSAPR_SID_ENUM_BUFFER;
+
+typedef enum _LSAP_LOOKUP_LEVEL {
+        LsapLookupWksta = 1,
+        LsapLookupPDC,
+        LsapLookupTDL,
+        LsapLookupGC,
+        LsapLookupXForestReferral,
+        LsapLookupXForestResolve,
+        LsapLookupRODCReferralToFullDC
+} LSAP_LOOKUP_LEVEL, *PLSAP_LOOKUP_LEVEL;
+
+typedef struct _LSAPR_TRUST_INFORMATION {
+        char *Name;
+        RPC_SID Sid;
+} LSAPR_TRUST_INFORMATION, *PLSAPR_TRUST_INFORMATION;
+
+typedef struct _LSAPR_REFERENCED_DOMAIN_LIST {
+        uint32_t Entries;
+        LSAPR_TRUST_INFORMATION *Domains;
+        uint32_t MaxEntries; /* must be ignored */
+} LSAPR_REFERENCED_DOMAIN_LIST, *PLSAPR_REFERENCED_DOMAIN_LIST;
+
+/* For OPENPOLICY2: RootDirectory MUST be zero. Everything else is ignored. */
+typedef struct _LSAPR_OBJECT_ATTRIBUTES {
+        uint32_t Length;
+        unsigned char *RootDirectory;
+        void *ObjectName;
+        uint32_t Attributes;
+        void *SecurityDescriptor;
+        void *SecurityQualityOfService;
+} LSAPR_OBJECT_ATTRIBUTES, *PLSAPR_OBJECT_ATTRIBUTES;
+
+struct lsa_close_req {
+        struct ndr_context_handle PolicyHandle;
+};
+
+struct lsa_close_rep {
+        uint32_t status;
+
+        struct ndr_context_handle PolicyHandle;
+};
+
+struct lsa_openpolicy2_req {
+        char *SystemName;
+        LSAPR_OBJECT_ATTRIBUTES ObjectAttributes;
+        uint32_t DesiredAccess;
+};
+
+struct lsa_openpolicy2_rep {
+        uint32_t status;
+
+        struct ndr_context_handle PolicyHandle;
+};
+
+struct lsa_lookupsids2_req {
+        struct ndr_context_handle PolicyHandle;
+        LSAPR_SID_ENUM_BUFFER SidEnumBuffer;
+        LSAPR_TRANSLATED_NAMES_EX TranslatedNames;
+        LSAP_LOOKUP_LEVEL LookupLevel;
+};
+
+struct lsa_lookupsids2_rep {
+        uint32_t status;
+
+        LSAPR_REFERENCED_DOMAIN_LIST ReferencedDomains;
+        LSAPR_TRANSLATED_NAMES_EX TranslatedNames;
+        uint32_t MappedCount;
+};
+
+int lsa_Close_rep_coder(struct dcerpc_context *dce,
+                        struct dcerpc_pdu *pdu,
+                        struct smb2_iovec *iov, int *offset,
+                        void *ptr);
+int lsa_Close_req_coder(struct dcerpc_context *dce,
+                        struct dcerpc_pdu *pdu,
+                        struct smb2_iovec *iov, int *offset,
+                        void *ptr);
+int lsa_LookupSids2_rep_coder(struct dcerpc_context *dce,
+                              struct dcerpc_pdu *pdu,
+                              struct smb2_iovec *iov, int *offset,
+                              void *ptr);
+int lsa_LookupSids2_req_coder(struct dcerpc_context *dce,
+                              struct dcerpc_pdu *pdu,
+                              struct smb2_iovec *iov, int *offset,
+                              void *ptr);
+int lsa_OpenPolicy2_rep_coder(struct dcerpc_context *dce,
+                              struct dcerpc_pdu *pdu,
+                              struct smb2_iovec *iov, int *offset,
+                              void *ptr);
+int lsa_OpenPolicy2_req_coder(struct dcerpc_context *dce,
+                              struct dcerpc_pdu *pdu,
+                              struct smb2_iovec *iov, int *offset,
+                              void *ptr);
+int lsa_RPC_SID_coder(struct dcerpc_context *dce,
+                      struct dcerpc_pdu *pdu,
+                      struct smb2_iovec *iov, int *offset,
+                      void *ptr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_LIBSMB2_DCERPC_LSA_H_ */

package/ios/include/smb2/libsmb2-dcerpc-srvsvc.h

@@ -0,0 +1,180 @@
+/* -*-  mode:c; tab-width:8; c-basic-offset:8; indent-tabs-mode:nil;  -*- */
+/*
+   Copyright (C) 2018 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as published by
+   the Free Software Foundation; either version 2.1 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _LIBSMB2_DCERPC_SRVSVC_H_
+#define _LIBSMB2_DCERPC_SRVSVC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <smb2/libsmb2-dcerpc.h>
+
+#define SRVSVC_NETRSHAREENUM      0x0f
+#define SRVSVC_NETRSHAREGETINFO   0x10
+
+struct dcerpc_context;
+struct dcerpc_pdu;
+
+
+/* Low 2 bits desctibe the type */
+#define SHARE_TYPE_DISKTREE  0
+#define SHARE_TYPE_PRINTQ    1
+#define SHARE_TYPE_DEVICE    2
+#define SHARE_TYPE_IPC       3
+
+#define SHARE_TYPE_TEMPORARY 0x40000000
+#define SHARE_TYPE_HIDDEN    0x80000000
+
+enum SHARE_INFO_enum {
+        SHARE_INFO_0 = 0,
+        SHARE_INFO_1 = 1,
+};
+
+struct srvsvc_SHARE_INFO_0 {
+        struct dcerpc_utf16 netname;
+};
+int srvsvc_SHARE_INFO_0_coder(struct dcerpc_context *ctx,
+                              struct dcerpc_pdu *pdu,
+                              struct smb2_iovec *iov, int *offset,
+                              void *ptr);
+
+struct srvsvc_SHARE_INFO_0_carray {
+        uint32_t max_count;
+        struct srvsvc_SHARE_INFO_0 *share_info_0;
+};
+
+struct srvsvc_SHARE_INFO_0_CONTAINER {
+        uint32_t EntriesRead;
+        struct srvsvc_SHARE_INFO_0_carray *Buffer;
+};
+
+struct srvsvc_SHARE_INFO_1 {
+        struct dcerpc_utf16 netname;
+        uint32_t type;
+        struct dcerpc_utf16 remark;
+};
+int srvsvc_SHARE_INFO_1_coder(struct dcerpc_context *ctx,
+                              struct dcerpc_pdu *pdu,
+                              struct smb2_iovec *iov, int *offset,
+                              void *ptr);
+
+struct srvsvc_SHARE_INFO_1_carray {
+        uint32_t max_count;
+        struct srvsvc_SHARE_INFO_1 *share_info_1;
+};
+
+struct srvsvc_SHARE_INFO_1_CONTAINER {
+        uint32_t EntriesRead;
+        struct srvsvc_SHARE_INFO_1_carray *Buffer;
+};
+        
+int srvsvc_SHARE_INFO_1_CONTAINER_coder(struct dcerpc_context *dce,
+                                        struct dcerpc_pdu *pdu,
+                                        struct smb2_iovec *iov, int *offset,
+                                        void *ptr);
+
+struct srvsvc_SHARE_ENUM_UNION {
+        uint32_t Level;
+        union {
+                struct srvsvc_SHARE_INFO_0_CONTAINER Level0;
+                struct srvsvc_SHARE_INFO_1_CONTAINER Level1;
+        };
+};
+
+struct srvsvc_SHARE_ENUM_STRUCT {
+        uint32_t Level;
+        struct srvsvc_SHARE_ENUM_UNION ShareInfo;
+};
+
+struct srvsvc_NetrShareEnum_req {
+        struct dcerpc_utf16 ServerName;
+        struct srvsvc_SHARE_ENUM_STRUCT ses;
+        uint32_t PreferedMaximumLength;
+        uint32_t ResumeHandle;
+};
+
+struct srvsvc_NetrShareEnum_rep {
+        uint32_t status;
+
+        struct srvsvc_SHARE_ENUM_STRUCT ses;
+        uint32_t total_entries;
+        uint32_t resume_handle;
+};
+
+struct srvsvc_SHARE_INFO {
+        uint32_t level;
+        union {
+                struct srvsvc_SHARE_INFO_1 ShareInfo1;
+        };
+};
+
+struct srvsvc_NetrShareGetInfo_req {
+        struct dcerpc_utf16 ServerName;
+        struct dcerpc_utf16 NetName;
+        uint32_t Level;
+};
+
+struct srvsvc_NetrShareGetInfo_rep {
+        uint32_t status;
+
+        struct srvsvc_SHARE_INFO InfoStruct;
+};
+
+struct srvsvc_rep {
+        uint32_t status;
+};
+
+/*
+ * Async share_enum()
+ * This function only works when connected to the IPC$ share.
+ *
+ * Returns
+ *  0     : The operation was initiated. Result of the operation will be
+ *          reported through the callback function.
+ * -errno : There was an error. The callback function will not be invoked.
+ *
+ * When the callback is invoked, status indicates the result:
+ *      0 : Success. Command_data is struct srvsvc_NetrShareEnum_rep *
+ *          This pointer must be freed using smb2_free_data().
+ * -errno : An error occurred.
+ */
+int smb2_share_enum_async(struct smb2_context *smb2, enum SHARE_INFO_enum level,
+                          smb2_command_cb cb, void *cb_data);
+
+int srvsvc_NetrShareEnum_rep_coder(struct dcerpc_context *dce,
+                                   struct dcerpc_pdu *pdu,
+                                   struct smb2_iovec *iov, int *offset,
+                                   void *ptr);
+int srvsvc_NetrShareEnum_req_coder(struct dcerpc_context *ctx,
+                                   struct dcerpc_pdu *pdu,
+                                   struct smb2_iovec *iov, int *offset,
+                                   void *ptr);
+int srvsvc_NetrShareGetInfo_rep_coder(struct dcerpc_context *dce,
+                                      struct dcerpc_pdu *pdu,
+                                      struct smb2_iovec *iov, int *offset,
+                                      void *ptr);
+int srvsvc_NetrShareGetInfo_req_coder(struct dcerpc_context *ctx,
+                                      struct dcerpc_pdu *pdu,
+                                      struct smb2_iovec *iov, int *offset,
+                                      void *ptr);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_LIBSMB2_DCERPC_SRVSVC_H_ */