/src/wireshark/epan/dissectors/packet-fmp_notify.c

Source
/* packet-fmp_notify.c
 * Routines for fmp dissection
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

#include "config.h"

#include <epan/packet.h>

#include "packet-rpc.h"
#include "packet-fmp.h"

void proto_register_fmp_notify(void);
void proto_reg_handoff_fmp_notify(void);

#define FMP_NOTIFY_PROG   1001912
#define FMP_NOTIFY_VERSION_2        2

/*
 * FMP/NOTIFY Procedures
 */
#define FMP_NOTIFY_DownGrade    1
#define FMP_NOTIFY_RevokeList   2
#define FMP_NOTIFY_RevokeAll    3
#define FMP_NOTIFY_FileSetEof   4
#define FMP_NOTIFY_RequestDone    5
#define FMP_NOTIFY_volFreeze    6
#define FMP_NOTIFY_revokeHandleList 7

typedef enum {
  FMP_LIST_USER_QUOTA_EXCEEDED  = 0,
  FMP_LIST_GROUP_QUOTA_EXCEEDED = 1,
  FMP_LIST_SERVER_RESOURCE_LOW  = 2
} revokeHandleListReason;

static int proto_fmp_notify;
static int hf_fmp_handleListLen;
static int hf_fmp_notify_procedure;
static int hf_fmp_fsID;
/* static int hf_fmp_fsBlkSz; */
static int hf_fmp_sessionHandle;
static int hf_fmp_fmpFHandle;
static int hf_fmp_msgNum;
static int hf_fmp_fileSize;
static int hf_fmp_cookie;
static int hf_fmp_firstLogBlk;
static int hf_fmp_numBlksReq;
static int hf_fmp_status;
static int hf_fmp_extentList_len;
static int hf_fmp_numBlks;
static int hf_fmp_volID;
static int hf_fmp_startOffset;
static int hf_fmp_extent_state;
static int hf_fmp_revokeHandleListReason;

static int ett_fmp_notify;
static int ett_fmp_notify_hlist;
static int ett_fmp_extList;
static int ett_fmp_ext;


static int dissect_fmp_notify_extentList(tvbuff_t *, int, packet_info *, proto_tree *);

static int
dissect_fmp_notify_status(tvbuff_t *tvb, int offset, proto_tree *tree, int *rval)
{
  fmpStat status;

  status = (fmpStat)tvb_get_ntohl(tvb, offset);

  switch (status) {
  case FMP_OK:
    *rval = 0;
    break;
  case FMP_IOERROR:
    *rval = 1;
    break;
  case FMP_NOMEM:
    *rval = 1;
    break;
  case FMP_NOACCESS:
    *rval = 1;
    break;
   case FMP_INVALIDARG:
    *rval = 1;
    break;
  case FMP_FSFULL:
    *rval = 0;
    break;
  case FMP_QUEUE_FULL:
    *rval = 1;
    break;
  case FMP_WRONG_MSG_NUM:
    *rval = 1;
    break;
  case FMP_SESSION_LOST:
    *rval = 1;
    break;
  case FMP_HOT_SESSION:
    *rval = 0;
    break;

  case FMP_COLD_SESSION:
    *rval = 0;
    break;
  case FMP_CLIENT_TERMINATED:
    *rval = 0;
    break;
  case FMP_WRITER_LOST_BLK:
    *rval = 1;
    break;
  case FMP_REQUEST_QUEUED:
    *rval = 0;
    break;
  case FMP_FALL_BACK:
    *rval = 0;
    break;
  case FMP_REQUEST_CANCELLED:
    *rval = 1;
    break;

         case FMP_WRITER_ZEROED_BLK:
    *rval = 0;
    break;
  case FMP_NOTIFY_ERROR:
    *rval = 1;
    break;
  case FMP_WRONG_HANDLE:
    *rval = 0;
    break;
  case FMP_DUPLICATE_OPEN:
    *rval = 1;
    break;
  case FMP_PLUGIN_NOFUNC:
    *rval = 1;
    break;
  default:
    *rval = 1;
    break;
  }

  offset = dissect_rpc_uint32(tvb, tree, hf_fmp_status , offset);
  return offset;

}

static int
dissect_revokeHandleListReason(tvbuff_t *tvb, int offset, proto_tree *tree)
{
  proto_tree_add_item(tree, hf_fmp_revokeHandleListReason, tvb, offset, 4, ENC_BIG_ENDIAN);
  offset += 4;
  return offset;
}

static int
dissect_handleList(tvbuff_t *tvb, int offset, packet_info *pinfo,
       proto_tree *tree)
{

  unsigned    numHandles;
  proto_tree *handleListTree;
  proto_item *ti;

  numHandles = tvb_get_ntohl(tvb, offset);

  handleListTree =  proto_tree_add_subtree(tree, tvb, offset, 4,
                ett_fmp_notify_hlist, &ti, "Handle List");

  offset = dissect_rpc_uint32(tvb,  handleListTree,
            hf_fmp_handleListLen, offset);

  for (unsigned i = 0; i < numHandles; i++) {
    offset = dissect_rpc_data(tvb, pinfo, handleListTree,
            hf_fmp_fmpFHandle, offset);/*  changed */
  }

  proto_item_set_end(ti, tvb, offset);

  return offset;
}

static int
dissect_FMP_NOTIFY_DownGrade_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
  unsigned offset = 0;

  offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_sessionHandle,
          offset);
  offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_fmpFHandle, offset);
  offset = dissect_rpc_uint32(tvb, tree, hf_fmp_msgNum, offset);
  offset = dissect_rpc_uint32(tvb, tree, hf_fmp_firstLogBlk,
            offset);
  offset = dissect_rpc_uint32(tvb, tree, hf_fmp_numBlksReq, offset);
  return offset;
}

static int
dissect_FMP_NOTIFY_DownGrade_reply(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
  int rval;

  return dissect_fmp_notify_status(tvb, 0,tree, &rval);
}

static int
dissect_FMP_NOTIFY_RevokeList_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
  unsigned offset = 0;

  offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_sessionHandle,
          offset);
  offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_fmpFHandle, offset);
  offset = dissect_rpc_uint32(tvb, tree, hf_fmp_msgNum, offset);
  offset = dissect_rpc_uint32(tvb, tree, hf_fmp_firstLogBlk,
            offset);
  offset = dissect_rpc_uint32(tvb, tree, hf_fmp_numBlksReq, offset);
  return offset;
}

static int
dissect_FMP_NOTIFY_RevokeList_reply(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
  int rval;

  return dissect_fmp_notify_status(tvb, 0, tree, &rval);
}

static int
dissect_FMP_NOTIFY_RevokeAll_request(tvbuff_t *tvb,
             packet_info *pinfo, proto_tree *tree, void* data _U_)
{
  unsigned offset = 0;
  offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_sessionHandle,
          offset);
  offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_fmpFHandle, offset);
  offset = dissect_rpc_uint32(tvb, tree, hf_fmp_msgNum, offset);
  return offset;
}

static int
dissect_FMP_NOTIFY_RevokeAll_reply(tvbuff_t *tvb,
           packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
  int rval;

  return dissect_fmp_notify_status(tvb, 0, tree, &rval);
}

static int
dissect_FMP_NOTIFY_FileSetEof_request(tvbuff_t *tvb,
              packet_info *pinfo, proto_tree *tree, void* data _U_)
{
  unsigned offset = 0;
  offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_sessionHandle,
          offset);
  offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_fmpFHandle, offset);
  offset = dissect_rpc_uint32(tvb, tree, hf_fmp_msgNum, offset);
  offset = dissect_rpc_uint64(tvb, tree, hf_fmp_fileSize, offset);
  return offset;
}

static int
dissect_FMP_NOTIFY_FileSetEof_reply(tvbuff_t *tvb,
            packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
  int rval;

  return dissect_fmp_notify_status(tvb, 0, tree, &rval);
}

static int
dissect_FMP_NOTIFY_RequestDone_request(tvbuff_t *tvb,
               packet_info *pinfo, proto_tree *tree, void* data _U_)
{
  int rval;
  unsigned offset = 0;

  offset = dissect_fmp_notify_status(tvb, offset,tree, &rval);
  if (rval == 0) {
    offset = dissect_rpc_data(tvb, pinfo, tree,
            hf_fmp_sessionHandle, offset);
    offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_fmpFHandle,
            offset);
    offset = dissect_rpc_uint32(tvb, tree, hf_fmp_msgNum,
              offset);
    offset = dissect_rpc_uint32(tvb, tree, hf_fmp_cookie,
              offset);
    offset = dissect_fmp_notify_extentList(tvb, offset, pinfo, tree);
  }
  return offset;
}

static int
dissect_FMP_NOTIFY_RequestDone_reply(tvbuff_t *tvb,
             packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
  int rval;

  return dissect_fmp_notify_status(tvb, 0, tree, &rval);
}

static int
dissect_FMP_NOTIFY_volFreeze_request(tvbuff_t *tvb,
             packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
  unsigned offset = 0;

  offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_sessionHandle,
          offset);
  offset = dissect_rpc_uint32(tvb, tree, hf_fmp_fsID, offset);
  return offset;
}

static int
dissect_FMP_NOTIFY_volFreeze_reply(tvbuff_t *tvb,
           packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
  int rval;

  return dissect_fmp_notify_status(tvb, 0, tree, &rval);
}

static int
dissect_FMP_NOTIFY_revokeHandleList_request(tvbuff_t *tvb,
              packet_info *pinfo, proto_tree *tree, void* data _U_)
{
  unsigned offset = 0;

  offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_sessionHandle, offset);
  offset = dissect_revokeHandleListReason(tvb, offset, tree);
  offset = dissect_handleList(tvb, offset, pinfo, tree);
  return offset;
}

static int
dissect_FMP_NOTIFY_revokeHandleList_reply(tvbuff_t *tvb,
            packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
  int rval;

  return dissect_fmp_notify_status(tvb, 0, tree, &rval);
}

/*
 * proc number, "proc name", dissect_request, dissect_reply
 */
static const vsff fmp_notify2_proc[] = {
  { 0,            "NULL",
    dissect_rpc_void,
    dissect_rpc_void, },

  { FMP_NOTIFY_DownGrade,       "DownGrade",
    dissect_FMP_NOTIFY_DownGrade_request,
    dissect_FMP_NOTIFY_DownGrade_reply },

  { FMP_NOTIFY_RevokeList,      "RevokeList",
    dissect_FMP_NOTIFY_RevokeList_request,
    dissect_FMP_NOTIFY_RevokeList_reply },

  { FMP_NOTIFY_RevokeAll,       "RevokeAll",
    dissect_FMP_NOTIFY_RevokeAll_request,
    dissect_FMP_NOTIFY_RevokeAll_reply },

  { FMP_NOTIFY_FileSetEof,      "FileSetEof",
    dissect_FMP_NOTIFY_FileSetEof_request,
    dissect_FMP_NOTIFY_FileSetEof_reply },

  { FMP_NOTIFY_RequestDone,     "RequestDone",
    dissect_FMP_NOTIFY_RequestDone_request,
    dissect_FMP_NOTIFY_RequestDone_reply },

  { FMP_NOTIFY_volFreeze,       "volFreeze",
    dissect_FMP_NOTIFY_volFreeze_request,
    dissect_FMP_NOTIFY_volFreeze_reply },

  { FMP_NOTIFY_revokeHandleList,      "revokeHandleList",
    dissect_FMP_NOTIFY_revokeHandleList_request,
    dissect_FMP_NOTIFY_revokeHandleList_reply },

  { 0,    NULL,   NULL,   NULL }
};

static const rpc_prog_vers_info fmp_notify_vers_info[] = {
  { FMP_NOTIFY_VERSION_2, fmp_notify2_proc, &hf_fmp_notify_procedure }
};

static const value_string fmp_notify_proc_vals[] = {
  { 0, "NULL" },
  { 1, "DownGrade" },
  { 2, "RevokeList" },
  { 3, "RevokeAll" },
  { 4, "FileSetEof" },
  { 5, "RequestDone" },
  { 6, "VolFreeze" },
  { 7, "RevokeHandleList" },
  { 0,NULL}
};

static const value_string fmp_status_vals[] = {
  {  0, "OK"},
  {  5, "IOERROR"},
  { 12, "NOMEM"},
  { 13, "NOACCESS"},
  { 22, "INVALIDARG"},
  { 28, "FSFULL"},
  { 79, "QUEUE_FULL"},
  {500, "WRONG_MSG_NUM"},
  {501, "SESSION_LOST"},
  {502, "HOT_SESSION"},
  {503, "COLD_SESSION"},
  {504, "CLIENT_TERMINATED"},
  {505, "WRITER_LOST_BLK"},
  {506, "FMP_REQUEST_QUEUED"},
  {507, "FMP_FALL_BACK"},
  {508, "REQUEST_CANCELLED"},
  {509, "WRITER_ZEROED_BLK"},
  {510, "NOTIFY_ERROR"},
  {511, "FMP_WRONG_HANDLE"},
  {512, "DUPLICATE_OPEN"},
  {600, "PLUGIN_NOFUNC"},
  {0,NULL}

};

static const value_string fmp_revokeHandleListReason_vals[] = {
  {FMP_LIST_USER_QUOTA_EXCEEDED,  "LIST_USER_QUOTA_EXCEEDED"},
  {FMP_LIST_GROUP_QUOTA_EXCEEDED, "LIST_GROUP_QUOTA_EXCEEDED"},
  {FMP_LIST_SERVER_RESOURCE_LOW,  "LIST_SERVER_RESOURCE_LOW"},
  {0,NULL}
};

static int
dissect_fmp_notify_extentState(tvbuff_t *tvb, int offset, proto_tree *tree)
{
  offset = dissect_rpc_uint32(tvb, tree, hf_fmp_extent_state,
            offset);

  return offset;
}

static int
dissect_fmp_notify_extent(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
       proto_tree *tree, uint32_t ext_num)
{
  proto_tree *extTree;

  extTree = proto_tree_add_subtree_format(tree, tvb, offset, 20 ,
              ett_fmp_ext, NULL, "Extent (%u)", (uint32_t) ext_num);

  offset = dissect_rpc_uint32(tvb,  extTree, hf_fmp_firstLogBlk,
            offset);
  offset = dissect_rpc_uint32(tvb, extTree, hf_fmp_numBlks,
            offset);
  offset = dissect_rpc_uint32(tvb, extTree, hf_fmp_volID, offset);
  offset = dissect_rpc_uint32(tvb, extTree, hf_fmp_startOffset,
            offset);
  offset = dissect_fmp_notify_extentState(tvb, offset, extTree);

  return offset;
}


static int
dissect_fmp_notify_extentList(tvbuff_t *tvb, int offset, packet_info *pinfo,
           proto_tree *tree)
{
  uint32_t      numExtents;
  uint32_t      totalLength;
  proto_tree *extListTree;
  uint32_t      i;

  numExtents = tvb_get_ntohl(tvb, offset);
  totalLength = 4 + (20 * numExtents);

  extListTree =  proto_tree_add_subtree(tree, tvb, offset, totalLength,
             ett_fmp_extList, NULL, "Extent List");

  offset = dissect_rpc_uint32(tvb, extListTree,
            hf_fmp_extentList_len, offset);

  for (i = 0; i < numExtents; i++) {
    offset = dissect_fmp_notify_extent(tvb, offset, pinfo, extListTree, i+1);
  }

  return offset;
}

void
proto_register_fmp_notify(void)
{
  static hf_register_info hf[] = {
    { &hf_fmp_notify_procedure, {
      "Procedure", "fmp_notify.notify_procedure", FT_UINT32, BASE_DEC,
      VALS(fmp_notify_proc_vals) , 0, NULL, HFILL }},         /* New addition */

    { &hf_fmp_status, {
      "Status", "fmp_notify.status", FT_UINT32, BASE_DEC,
      VALS(fmp_status_vals), 0, "Reply Status", HFILL }},

    { &hf_fmp_extentList_len, {
      "Extent List length", "fmp_notify.extentListLength",
      FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }},

    { &hf_fmp_numBlks, {
      "Number Blocks", "fmp_notify.numBlks", FT_UINT32,
      BASE_DEC, NULL, 0, NULL, HFILL }},

    { &hf_fmp_volID, {
      "Volume ID", "fmp_notify.volID", FT_UINT32,
      BASE_DEC, NULL, 0, NULL, HFILL }},

    { &hf_fmp_startOffset, {
      "Start Offset", "fmp_notify.startOffset", FT_UINT32,
      BASE_DEC, NULL, 0, NULL, HFILL }},

    { &hf_fmp_extent_state, {
      "Extent State", "fmp_notify.extentState", FT_UINT32,
      BASE_DEC, NULL, 0, NULL, HFILL }},

    { &hf_fmp_handleListLen, {
      "Number of File Handles", "fmp_notify.handleListLength",
      FT_UINT32, BASE_DEC, NULL, 0,
      NULL, HFILL }},

    { &hf_fmp_sessionHandle, {
      "Session Handle", "fmp_notify.sessHandle", FT_BYTES, BASE_NONE,
      NULL, 0, NULL, HFILL }},


  { &hf_fmp_fsID, {
      "File System ID", "fmp_notify.fsID", FT_UINT32, BASE_HEX,
      NULL, 0, NULL, HFILL }},

#if 0
  { &hf_fmp_fsBlkSz, {
      "FS Block Size", "fmp_notify.fsBlkSz", FT_UINT32, BASE_DEC,
      NULL, 0, NULL, HFILL }},
#endif

  { &hf_fmp_numBlksReq, {
      "Number Blocks Requested", "fmp_notify.numBlksReq", FT_UINT32,
      BASE_DEC, NULL, 0, NULL, HFILL }},


  { &hf_fmp_msgNum, {
      "Message Number", "fmp_notify.msgNum", FT_UINT32, BASE_DEC,
      NULL, 0, NULL, HFILL }},

  { &hf_fmp_cookie, {
      "Cookie", "fmp_notify.cookie", FT_UINT32, BASE_HEX,
      NULL, 0, "Cookie for FMP_REQUEST_QUEUED Resp", HFILL }},


  { &hf_fmp_firstLogBlk, {
      "First Logical Block", "fmp_notify.firstLogBlk", FT_UINT32,
      BASE_DEC, NULL, 0, "First Logical File Block", HFILL }},


  { &hf_fmp_fileSize, {
      "File Size", "fmp_notify.fileSize", FT_UINT64, BASE_DEC,
      NULL, 0, NULL, HFILL }},

    { &hf_fmp_fmpFHandle, {
      "FMP File Handle", "fmp_notify.fmpFHandle",
      FT_BYTES, BASE_NONE, NULL, 0, NULL,
      HFILL }},

  { &hf_fmp_revokeHandleListReason,
    { "Reason", "fmp.revokeHandleListReason",
      FT_UINT32, BASE_DEC, VALS(fmp_revokeHandleListReason_vals), 0,
      NULL, HFILL }},


  };

  static int *ett[] = {
    &ett_fmp_notify,
    &ett_fmp_notify_hlist,
    &ett_fmp_extList,
    &ett_fmp_ext
  };

  proto_fmp_notify =
    proto_register_protocol("File Mapping Protocol Notify",
          "FMP/NOTIFY", "fmp_notify");
  proto_register_field_array(proto_fmp_notify, hf, array_length(hf));
  proto_register_subtree_array(ett, array_length(ett));

}

void
proto_reg_handoff_fmp_notify(void)
{
  /* Register the protocol as RPC */
  rpc_init_prog(proto_fmp_notify, FMP_NOTIFY_PROG, ett_fmp_notify,
                      G_N_ELEMENTS(fmp_notify_vers_info), fmp_notify_vers_info);
}

/*
 * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 *
 * Local variables:
 * c-basic-offset: 8
 * tab-width: 8
 * indent-tabs-mode: t
 * End:
 *
 * vi: set shiftwidth=8 tabstop=8 noexpandtab:
 * :indentSize=8:tabSize=8:noTabs=false:
 */

Coverage Report

Created: 2026-07-12 07:10

Line	Count	Source
1		/* packet-fmp_notify.c
2		* Routines for fmp dissection
3		*
4		* Wireshark - Network traffic analyzer
5		* By Gerald Combs <gerald@wireshark.org>
6		* Copyright 1998 Gerald Combs
7		*
8		* SPDX-License-Identifier: GPL-2.0-or-later
9		*/
10
11		#include "config.h"
12
13		#include <epan/packet.h>
14
15		#include "packet-rpc.h"
16		#include "packet-fmp.h"
17
18		void proto_register_fmp_notify(void);
19		void proto_reg_handoff_fmp_notify(void);
20
21	15	#define FMP_NOTIFY_PROG 1001912
22		#define FMP_NOTIFY_VERSION_2 2
23
24		/*
25		* FMP/NOTIFY Procedures
26		*/
27		#define FMP_NOTIFY_DownGrade 1
28		#define FMP_NOTIFY_RevokeList 2
29		#define FMP_NOTIFY_RevokeAll 3
30		#define FMP_NOTIFY_FileSetEof 4
31		#define FMP_NOTIFY_RequestDone 5
32		#define FMP_NOTIFY_volFreeze 6
33		#define FMP_NOTIFY_revokeHandleList 7
34
35		typedef enum {
36		FMP_LIST_USER_QUOTA_EXCEEDED = 0,
37		FMP_LIST_GROUP_QUOTA_EXCEEDED = 1,
38		FMP_LIST_SERVER_RESOURCE_LOW = 2
39		} revokeHandleListReason;
40
41		static int proto_fmp_notify;
42		static int hf_fmp_handleListLen;
43		static int hf_fmp_notify_procedure;
44		static int hf_fmp_fsID;
45		/* static int hf_fmp_fsBlkSz; */
46		static int hf_fmp_sessionHandle;
47		static int hf_fmp_fmpFHandle;
48		static int hf_fmp_msgNum;
49		static int hf_fmp_fileSize;
50		static int hf_fmp_cookie;
51		static int hf_fmp_firstLogBlk;
52		static int hf_fmp_numBlksReq;
53		static int hf_fmp_status;
54		static int hf_fmp_extentList_len;
55		static int hf_fmp_numBlks;
56		static int hf_fmp_volID;
57		static int hf_fmp_startOffset;
58		static int hf_fmp_extent_state;
59		static int hf_fmp_revokeHandleListReason;
60
61		static int ett_fmp_notify;
62		static int ett_fmp_notify_hlist;
63		static int ett_fmp_extList;
64		static int ett_fmp_ext;
65
66
67		static int dissect_fmp_notify_extentList(tvbuff_t , int, packet_info , proto_tree *);
68
69		static int
70		dissect_fmp_notify_status(tvbuff_t tvb, int offset, proto_tree tree, int *rval)
71	0	{
72	0	fmpStat status;
73
74	0	status = (fmpStat)tvb_get_ntohl(tvb, offset);
75
76	0	switch (status) {
77	0	case FMP_OK:
78	0	*rval = 0;
79	0	break;
80	0	case FMP_IOERROR:
81	0	*rval = 1;
82	0	break;
83	0	case FMP_NOMEM:
84	0	*rval = 1;
85	0	break;
86	0	case FMP_NOACCESS:
87	0	*rval = 1;
88	0	break;
89	0	case FMP_INVALIDARG:
90	0	*rval = 1;
91	0	break;
92	0	case FMP_FSFULL:
93	0	*rval = 0;
94	0	break;
95	0	case FMP_QUEUE_FULL:
96	0	*rval = 1;
97	0	break;
98	0	case FMP_WRONG_MSG_NUM:
99	0	*rval = 1;
100	0	break;
101	0	case FMP_SESSION_LOST:
102	0	*rval = 1;
103	0	break;
104	0	case FMP_HOT_SESSION:
105	0	*rval = 0;
106	0	break;
107
108	0	case FMP_COLD_SESSION:
109	0	*rval = 0;
110	0	break;
111	0	case FMP_CLIENT_TERMINATED:
112	0	*rval = 0;
113	0	break;
114	0	case FMP_WRITER_LOST_BLK:
115	0	*rval = 1;
116	0	break;
117	0	case FMP_REQUEST_QUEUED:
118	0	*rval = 0;
119	0	break;
120	0	case FMP_FALL_BACK:
121	0	*rval = 0;
122	0	break;
123	0	case FMP_REQUEST_CANCELLED:
124	0	*rval = 1;
125	0	break;
126
127	0	case FMP_WRITER_ZEROED_BLK:
128	0	*rval = 0;
129	0	break;
130	0	case FMP_NOTIFY_ERROR:
131	0	*rval = 1;
132	0	break;
133	0	case FMP_WRONG_HANDLE:
134	0	*rval = 0;
135	0	break;
136	0	case FMP_DUPLICATE_OPEN:
137	0	*rval = 1;
138	0	break;
139	0	case FMP_PLUGIN_NOFUNC:
140	0	*rval = 1;
141	0	break;
142	0	default:
143	0	*rval = 1;
144	0	break;
145	0	}
146
147	0	offset = dissect_rpc_uint32(tvb, tree, hf_fmp_status , offset);
148	0	return offset;
149
150	0	}
151
152		static int
153		dissect_revokeHandleListReason(tvbuff_t tvb, int offset, proto_tree tree)
154	0	{
155	0	proto_tree_add_item(tree, hf_fmp_revokeHandleListReason, tvb, offset, 4, ENC_BIG_ENDIAN);
156	0	offset += 4;
157	0	return offset;
158	0	}
159
160		static int
161		dissect_handleList(tvbuff_t tvb, int offset, packet_info pinfo,
162		proto_tree *tree)
163	0	{
164
165	0	unsigned numHandles;
166	0	proto_tree *handleListTree;
167	0	proto_item *ti;
168
169	0	numHandles = tvb_get_ntohl(tvb, offset);
170
171	0	handleListTree = proto_tree_add_subtree(tree, tvb, offset, 4,
172	0	ett_fmp_notify_hlist, &ti, "Handle List");
173
174	0	offset = dissect_rpc_uint32(tvb, handleListTree,
175	0	hf_fmp_handleListLen, offset);
176
177	0	for (unsigned i = 0; i < numHandles; i++) {
178	0	offset = dissect_rpc_data(tvb, pinfo, handleListTree,
179	0	hf_fmp_fmpFHandle, offset);/* changed */
180	0	}
181
182	0	proto_item_set_end(ti, tvb, offset);
183
184	0	return offset;
185	0	}
186
187		static int
188		dissect_FMP_NOTIFY_DownGrade_request(tvbuff_t tvb, packet_info pinfo, proto_tree tree, void data _U_)
189	0	{
190	0	unsigned offset = 0;
191
192	0	offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_sessionHandle,
193	0	offset);
194	0	offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_fmpFHandle, offset);
195	0	offset = dissect_rpc_uint32(tvb, tree, hf_fmp_msgNum, offset);
196	0	offset = dissect_rpc_uint32(tvb, tree, hf_fmp_firstLogBlk,
197	0	offset);
198	0	offset = dissect_rpc_uint32(tvb, tree, hf_fmp_numBlksReq, offset);
199	0	return offset;
200	0	}
201
202		static int
203		dissect_FMP_NOTIFY_DownGrade_reply(tvbuff_t tvb, packet_info pinfo _U_, proto_tree tree, void data _U_)
204	0	{
205	0	int rval;
206
207	0	return dissect_fmp_notify_status(tvb, 0,tree, &rval);
208	0	}
209
210		static int
211		dissect_FMP_NOTIFY_RevokeList_request(tvbuff_t tvb, packet_info pinfo, proto_tree tree, void data _U_)
212	0	{
213	0	unsigned offset = 0;
214
215	0	offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_sessionHandle,
216	0	offset);
217	0	offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_fmpFHandle, offset);
218	0	offset = dissect_rpc_uint32(tvb, tree, hf_fmp_msgNum, offset);
219	0	offset = dissect_rpc_uint32(tvb, tree, hf_fmp_firstLogBlk,
220	0	offset);
221	0	offset = dissect_rpc_uint32(tvb, tree, hf_fmp_numBlksReq, offset);
222	0	return offset;
223	0	}
224
225		static int
226		dissect_FMP_NOTIFY_RevokeList_reply(tvbuff_t tvb, packet_info pinfo _U_, proto_tree tree, void data _U_)
227	0	{
228	0	int rval;
229
230	0	return dissect_fmp_notify_status(tvb, 0, tree, &rval);
231	0	}
232
233		static int
234		dissect_FMP_NOTIFY_RevokeAll_request(tvbuff_t *tvb,
235		packet_info pinfo, proto_tree tree, void* data _U_)
236	0	{
237	0	unsigned offset = 0;
238	0	offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_sessionHandle,
239	0	offset);
240	0	offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_fmpFHandle, offset);
241	0	offset = dissect_rpc_uint32(tvb, tree, hf_fmp_msgNum, offset);
242	0	return offset;
243	0	}
244
245		static int
246		dissect_FMP_NOTIFY_RevokeAll_reply(tvbuff_t *tvb,
247		packet_info pinfo _U_, proto_tree tree, void* data _U_)
248	0	{
249	0	int rval;
250
251	0	return dissect_fmp_notify_status(tvb, 0, tree, &rval);
252	0	}
253
254		static int
255		dissect_FMP_NOTIFY_FileSetEof_request(tvbuff_t *tvb,
256		packet_info pinfo, proto_tree tree, void* data _U_)
257	0	{
258	0	unsigned offset = 0;
259	0	offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_sessionHandle,
260	0	offset);
261	0	offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_fmpFHandle, offset);
262	0	offset = dissect_rpc_uint32(tvb, tree, hf_fmp_msgNum, offset);
263	0	offset = dissect_rpc_uint64(tvb, tree, hf_fmp_fileSize, offset);
264	0	return offset;
265	0	}
266
267		static int
268		dissect_FMP_NOTIFY_FileSetEof_reply(tvbuff_t *tvb,
269		packet_info pinfo _U_, proto_tree tree, void* data _U_)
270	0	{
271	0	int rval;
272
273	0	return dissect_fmp_notify_status(tvb, 0, tree, &rval);
274	0	}
275
276		static int
277		dissect_FMP_NOTIFY_RequestDone_request(tvbuff_t *tvb,
278		packet_info pinfo, proto_tree tree, void* data _U_)
279	0	{
280	0	int rval;
281	0	unsigned offset = 0;
282
283	0	offset = dissect_fmp_notify_status(tvb, offset,tree, &rval);
284	0	if (rval == 0) {
285	0	offset = dissect_rpc_data(tvb, pinfo, tree,
286	0	hf_fmp_sessionHandle, offset);
287	0	offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_fmpFHandle,
288	0	offset);
289	0	offset = dissect_rpc_uint32(tvb, tree, hf_fmp_msgNum,
290	0	offset);
291	0	offset = dissect_rpc_uint32(tvb, tree, hf_fmp_cookie,
292	0	offset);
293	0	offset = dissect_fmp_notify_extentList(tvb, offset, pinfo, tree);
294	0	}
295	0	return offset;
296	0	}
297
298		static int
299		dissect_FMP_NOTIFY_RequestDone_reply(tvbuff_t *tvb,
300		packet_info pinfo _U_, proto_tree tree, void* data _U_)
301	0	{
302	0	int rval;
303
304	0	return dissect_fmp_notify_status(tvb, 0, tree, &rval);
305	0	}
306
307		static int
308		dissect_FMP_NOTIFY_volFreeze_request(tvbuff_t *tvb,
309		packet_info pinfo _U_, proto_tree tree, void* data _U_)
310	0	{
311	0	unsigned offset = 0;
312
313	0	offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_sessionHandle,
314	0	offset);
315	0	offset = dissect_rpc_uint32(tvb, tree, hf_fmp_fsID, offset);
316	0	return offset;
317	0	}
318
319		static int
320		dissect_FMP_NOTIFY_volFreeze_reply(tvbuff_t *tvb,
321		packet_info pinfo _U_, proto_tree tree, void* data _U_)
322	0	{
323	0	int rval;
324
325	0	return dissect_fmp_notify_status(tvb, 0, tree, &rval);
326	0	}
327
328		static int
329		dissect_FMP_NOTIFY_revokeHandleList_request(tvbuff_t *tvb,
330		packet_info pinfo, proto_tree tree, void* data _U_)
331	0	{
332	0	unsigned offset = 0;
333
334	0	offset = dissect_rpc_data(tvb, pinfo, tree, hf_fmp_sessionHandle, offset);
335	0	offset = dissect_revokeHandleListReason(tvb, offset, tree);
336	0	offset = dissect_handleList(tvb, offset, pinfo, tree);
337	0	return offset;
338	0	}
339
340		static int
341		dissect_FMP_NOTIFY_revokeHandleList_reply(tvbuff_t *tvb,
342		packet_info pinfo _U_, proto_tree tree, void* data _U_)
343	0	{
344	0	int rval;
345
346	0	return dissect_fmp_notify_status(tvb, 0, tree, &rval);
347	0	}
348
349		/*
350		* proc number, "proc name", dissect_request, dissect_reply
351		*/
352		static const vsff fmp_notify2_proc[] = {
353		{ 0, "NULL",
354		dissect_rpc_void,
355		dissect_rpc_void, },
356
357		{ FMP_NOTIFY_DownGrade, "DownGrade",
358		dissect_FMP_NOTIFY_DownGrade_request,
359		dissect_FMP_NOTIFY_DownGrade_reply },
360
361		{ FMP_NOTIFY_RevokeList, "RevokeList",
362		dissect_FMP_NOTIFY_RevokeList_request,
363		dissect_FMP_NOTIFY_RevokeList_reply },
364
365		{ FMP_NOTIFY_RevokeAll, "RevokeAll",
366		dissect_FMP_NOTIFY_RevokeAll_request,
367		dissect_FMP_NOTIFY_RevokeAll_reply },
368
369		{ FMP_NOTIFY_FileSetEof, "FileSetEof",
370		dissect_FMP_NOTIFY_FileSetEof_request,
371		dissect_FMP_NOTIFY_FileSetEof_reply },
372
373		{ FMP_NOTIFY_RequestDone, "RequestDone",
374		dissect_FMP_NOTIFY_RequestDone_request,
375		dissect_FMP_NOTIFY_RequestDone_reply },
376
377		{ FMP_NOTIFY_volFreeze, "volFreeze",
378		dissect_FMP_NOTIFY_volFreeze_request,
379		dissect_FMP_NOTIFY_volFreeze_reply },
380
381		{ FMP_NOTIFY_revokeHandleList, "revokeHandleList",
382		dissect_FMP_NOTIFY_revokeHandleList_request,
383		dissect_FMP_NOTIFY_revokeHandleList_reply },
384
385		{ 0, NULL, NULL, NULL }
386		};
387
388		static const rpc_prog_vers_info fmp_notify_vers_info[] = {
389		{ FMP_NOTIFY_VERSION_2, fmp_notify2_proc, &hf_fmp_notify_procedure }
390		};
391
392		static const value_string fmp_notify_proc_vals[] = {
393		{ 0, "NULL" },
394		{ 1, "DownGrade" },
395		{ 2, "RevokeList" },
396		{ 3, "RevokeAll" },
397		{ 4, "FileSetEof" },
398		{ 5, "RequestDone" },
399		{ 6, "VolFreeze" },
400		{ 7, "RevokeHandleList" },
401		{ 0,NULL}
402		};
403
404		static const value_string fmp_status_vals[] = {
405		{ 0, "OK"},
406		{ 5, "IOERROR"},
407		{ 12, "NOMEM"},
408		{ 13, "NOACCESS"},
409		{ 22, "INVALIDARG"},
410		{ 28, "FSFULL"},
411		{ 79, "QUEUE_FULL"},
412		{500, "WRONG_MSG_NUM"},
413		{501, "SESSION_LOST"},
414		{502, "HOT_SESSION"},
415		{503, "COLD_SESSION"},
416		{504, "CLIENT_TERMINATED"},
417		{505, "WRITER_LOST_BLK"},
418		{506, "FMP_REQUEST_QUEUED"},
419		{507, "FMP_FALL_BACK"},
420		{508, "REQUEST_CANCELLED"},
421		{509, "WRITER_ZEROED_BLK"},
422		{510, "NOTIFY_ERROR"},
423		{511, "FMP_WRONG_HANDLE"},
424		{512, "DUPLICATE_OPEN"},
425		{600, "PLUGIN_NOFUNC"},
426		{0,NULL}
427
428		};
429
430		static const value_string fmp_revokeHandleListReason_vals[] = {
431		{FMP_LIST_USER_QUOTA_EXCEEDED, "LIST_USER_QUOTA_EXCEEDED"},
432		{FMP_LIST_GROUP_QUOTA_EXCEEDED, "LIST_GROUP_QUOTA_EXCEEDED"},
433		{FMP_LIST_SERVER_RESOURCE_LOW, "LIST_SERVER_RESOURCE_LOW"},
434		{0,NULL}
435		};
436
437		static int
438		dissect_fmp_notify_extentState(tvbuff_t tvb, int offset, proto_tree tree)
439	0	{
440	0	offset = dissect_rpc_uint32(tvb, tree, hf_fmp_extent_state,
441	0	offset);
442
443	0	return offset;
444	0	}
445
446		static int
447		dissect_fmp_notify_extent(tvbuff_t tvb, int offset, packet_info pinfo _U_,
448		proto_tree *tree, uint32_t ext_num)
449	0	{
450	0	proto_tree *extTree;
451
452	0	extTree = proto_tree_add_subtree_format(tree, tvb, offset, 20 ,
453	0	ett_fmp_ext, NULL, "Extent (%u)", (uint32_t) ext_num);
454
455	0	offset = dissect_rpc_uint32(tvb, extTree, hf_fmp_firstLogBlk,
456	0	offset);
457	0	offset = dissect_rpc_uint32(tvb, extTree, hf_fmp_numBlks,
458	0	offset);
459	0	offset = dissect_rpc_uint32(tvb, extTree, hf_fmp_volID, offset);
460	0	offset = dissect_rpc_uint32(tvb, extTree, hf_fmp_startOffset,
461	0	offset);
462	0	offset = dissect_fmp_notify_extentState(tvb, offset, extTree);
463
464	0	return offset;
465	0	}
466
467
468		static int
469		dissect_fmp_notify_extentList(tvbuff_t tvb, int offset, packet_info pinfo,
470		proto_tree *tree)
471	0	{
472	0	uint32_t numExtents;
473	0	uint32_t totalLength;
474	0	proto_tree *extListTree;
475	0	uint32_t i;
476
477	0	numExtents = tvb_get_ntohl(tvb, offset);
478	0	totalLength = 4 + (20 * numExtents);
479
480	0	extListTree = proto_tree_add_subtree(tree, tvb, offset, totalLength,
481	0	ett_fmp_extList, NULL, "Extent List");
482
483	0	offset = dissect_rpc_uint32(tvb, extListTree,
484	0	hf_fmp_extentList_len, offset);
485
486	0	for (i = 0; i < numExtents; i++) {
487	0	offset = dissect_fmp_notify_extent(tvb, offset, pinfo, extListTree, i+1);
488	0	}
489
490	0	return offset;
491	0	}
492
493		void
494		proto_register_fmp_notify(void)
495	15	{
496	15	static hf_register_info hf[] = {
497	15	{ &hf_fmp_notify_procedure, {
498	15	"Procedure", "fmp_notify.notify_procedure", FT_UINT32, BASE_DEC,
499	15	VALS(fmp_notify_proc_vals) , 0, NULL, HFILL }}, /* New addition */
500
501	15	{ &hf_fmp_status, {
502	15	"Status", "fmp_notify.status", FT_UINT32, BASE_DEC,
503	15	VALS(fmp_status_vals), 0, "Reply Status", HFILL }},
504
505	15	{ &hf_fmp_extentList_len, {
506	15	"Extent List length", "fmp_notify.extentListLength",
507	15	FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL }},
508
509	15	{ &hf_fmp_numBlks, {
510	15	"Number Blocks", "fmp_notify.numBlks", FT_UINT32,
511	15	BASE_DEC, NULL, 0, NULL, HFILL }},
512
513	15	{ &hf_fmp_volID, {
514	15	"Volume ID", "fmp_notify.volID", FT_UINT32,
515	15	BASE_DEC, NULL, 0, NULL, HFILL }},
516
517	15	{ &hf_fmp_startOffset, {
518	15	"Start Offset", "fmp_notify.startOffset", FT_UINT32,
519	15	BASE_DEC, NULL, 0, NULL, HFILL }},
520
521	15	{ &hf_fmp_extent_state, {
522	15	"Extent State", "fmp_notify.extentState", FT_UINT32,
523	15	BASE_DEC, NULL, 0, NULL, HFILL }},
524
525	15	{ &hf_fmp_handleListLen, {
526	15	"Number of File Handles", "fmp_notify.handleListLength",
527	15	FT_UINT32, BASE_DEC, NULL, 0,
528	15	NULL, HFILL }},
529
530	15	{ &hf_fmp_sessionHandle, {
531	15	"Session Handle", "fmp_notify.sessHandle", FT_BYTES, BASE_NONE,
532	15	NULL, 0, NULL, HFILL }},
533
534
535	15	{ &hf_fmp_fsID, {
536	15	"File System ID", "fmp_notify.fsID", FT_UINT32, BASE_HEX,
537	15	NULL, 0, NULL, HFILL }},
538
539		#if 0
540		{ &hf_fmp_fsBlkSz, {
541		"FS Block Size", "fmp_notify.fsBlkSz", FT_UINT32, BASE_DEC,
542		NULL, 0, NULL, HFILL }},
543		#endif
544
545	15	{ &hf_fmp_numBlksReq, {
546	15	"Number Blocks Requested", "fmp_notify.numBlksReq", FT_UINT32,
547	15	BASE_DEC, NULL, 0, NULL, HFILL }},
548
549
550	15	{ &hf_fmp_msgNum, {
551	15	"Message Number", "fmp_notify.msgNum", FT_UINT32, BASE_DEC,
552	15	NULL, 0, NULL, HFILL }},
553
554	15	{ &hf_fmp_cookie, {
555	15	"Cookie", "fmp_notify.cookie", FT_UINT32, BASE_HEX,
556	15	NULL, 0, "Cookie for FMP_REQUEST_QUEUED Resp", HFILL }},
557
558
559	15	{ &hf_fmp_firstLogBlk, {
560	15	"First Logical Block", "fmp_notify.firstLogBlk", FT_UINT32,
561	15	BASE_DEC, NULL, 0, "First Logical File Block", HFILL }},
562
563
564	15	{ &hf_fmp_fileSize, {
565	15	"File Size", "fmp_notify.fileSize", FT_UINT64, BASE_DEC,
566	15	NULL, 0, NULL, HFILL }},
567
568	15	{ &hf_fmp_fmpFHandle, {
569	15	"FMP File Handle", "fmp_notify.fmpFHandle",
570	15	FT_BYTES, BASE_NONE, NULL, 0, NULL,
571	15	HFILL }},
572
573	15	{ &hf_fmp_revokeHandleListReason,
574	15	{ "Reason", "fmp.revokeHandleListReason",
575	15	FT_UINT32, BASE_DEC, VALS(fmp_revokeHandleListReason_vals), 0,
576	15	NULL, HFILL }},
577
578
579	15	};
580
581	15	static int *ett[] = {
582	15	&ett_fmp_notify,
583	15	&ett_fmp_notify_hlist,
584	15	&ett_fmp_extList,
585	15	&ett_fmp_ext
586	15	};
587
588	15	proto_fmp_notify =
589	15	proto_register_protocol("File Mapping Protocol Notify",
590	15	"FMP/NOTIFY", "fmp_notify");
591	15	proto_register_field_array(proto_fmp_notify, hf, array_length(hf));
592	15	proto_register_subtree_array(ett, array_length(ett));
593
594	15	}
595
596		void
597		proto_reg_handoff_fmp_notify(void)
598	15	{
599		/* Register the protocol as RPC */
600	15	rpc_init_prog(proto_fmp_notify, FMP_NOTIFY_PROG, ett_fmp_notify,
601		G_N_ELEMENTS(fmp_notify_vers_info), fmp_notify_vers_info);
602	15	}
603
604		/*
605		* Editor modelines - https://www.wireshark.org/tools/modelines.html
606		*
607		* Local variables:
608		* c-basic-offset: 8
609		* tab-width: 8
610		* indent-tabs-mode: t
611		* End:
612		*
613		* vi: set shiftwidth=8 tabstop=8 noexpandtab:
614		* :indentSize=8:tabSize=8:noTabs=false:
615		*/