kinetic-c  v0.12.0
Seagate Kinetic Protocol Client Library for C
kinetic.pb-c.h
Go to the documentation of this file.
1 /* Generated by the protocol buffer compiler. DO NOT EDIT! */
2 /* Generated from: kinetic.proto */
3 
4 #ifndef PROTOBUF_C_kinetic_2eproto__INCLUDED
5 #define PROTOBUF_C_kinetic_2eproto__INCLUDED
6 
7 #include <protobuf-c/protobuf-c.h>
8 
9 PROTOBUF_C__BEGIN_DECLS
10 
11 #if PROTOBUF_C_VERSION_NUMBER < 1000000
12 # error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
13 #elif 1001000 < PROTOBUF_C_MIN_COMPILER_VERSION
14 # error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
15 #endif
16 
17 
19 typedef struct _Com__Seagate__Kinetic__Proto__Message Com__Seagate__Kinetic__Proto__Message;
20 typedef struct _Com__Seagate__Kinetic__Proto__Message__HMACauth Com__Seagate__Kinetic__Proto__Message__HMACauth;
21 typedef struct _Com__Seagate__Kinetic__Proto__Message__PINauth Com__Seagate__Kinetic__Proto__Message__PINauth;
22 typedef struct _Com__Seagate__Kinetic__Proto__Command Com__Seagate__Kinetic__Proto__Command;
23 typedef struct _Com__Seagate__Kinetic__Proto__Command__Header Com__Seagate__Kinetic__Proto__Command__Header;
24 typedef struct _Com__Seagate__Kinetic__Proto__Command__Body Com__Seagate__Kinetic__Proto__Command__Body;
25 typedef struct _Com__Seagate__Kinetic__Proto__Command__Status Com__Seagate__Kinetic__Proto__Command__Status;
26 typedef struct _Com__Seagate__Kinetic__Proto__Command__KeyValue Com__Seagate__Kinetic__Proto__Command__KeyValue;
27 typedef struct _Com__Seagate__Kinetic__Proto__Command__Range Com__Seagate__Kinetic__Proto__Command__Range;
28 typedef struct _Com__Seagate__Kinetic__Proto__Command__Setup Com__Seagate__Kinetic__Proto__Command__Setup;
29 typedef struct _Com__Seagate__Kinetic__Proto__Command__P2POperation Com__Seagate__Kinetic__Proto__Command__P2POperation;
30 typedef struct _Com__Seagate__Kinetic__Proto__Command__P2POperation__Operation Com__Seagate__Kinetic__Proto__Command__P2POperation__Operation;
31 typedef struct _Com__Seagate__Kinetic__Proto__Command__P2POperation__Peer Com__Seagate__Kinetic__Proto__Command__P2POperation__Peer;
32 typedef struct _Com__Seagate__Kinetic__Proto__Command__GetLog Com__Seagate__Kinetic__Proto__Command__GetLog;
33 typedef struct _Com__Seagate__Kinetic__Proto__Command__GetLog__Utilization Com__Seagate__Kinetic__Proto__Command__GetLog__Utilization;
34 typedef struct _Com__Seagate__Kinetic__Proto__Command__GetLog__Temperature Com__Seagate__Kinetic__Proto__Command__GetLog__Temperature;
35 typedef struct _Com__Seagate__Kinetic__Proto__Command__GetLog__Capacity Com__Seagate__Kinetic__Proto__Command__GetLog__Capacity;
36 typedef struct _Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration;
37 typedef struct _Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration__Interface Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration__Interface;
38 typedef struct _Com__Seagate__Kinetic__Proto__Command__GetLog__Statistics Com__Seagate__Kinetic__Proto__Command__GetLog__Statistics;
39 typedef struct _Com__Seagate__Kinetic__Proto__Command__GetLog__Limits Com__Seagate__Kinetic__Proto__Command__GetLog__Limits;
40 typedef struct _Com__Seagate__Kinetic__Proto__Command__GetLog__Device Com__Seagate__Kinetic__Proto__Command__GetLog__Device;
41 typedef struct _Com__Seagate__Kinetic__Proto__Command__Security Com__Seagate__Kinetic__Proto__Command__Security;
42 typedef struct _Com__Seagate__Kinetic__Proto__Command__Security__ACL Com__Seagate__Kinetic__Proto__Command__Security__ACL;
43 typedef struct _Com__Seagate__Kinetic__Proto__Command__Security__ACL__Scope Com__Seagate__Kinetic__Proto__Command__Security__ACL__Scope;
44 typedef struct _Com__Seagate__Kinetic__Proto__Command__PinOperation Com__Seagate__Kinetic__Proto__Command__PinOperation;
45 
46 
47 /* --- enums --- */
48 
49 /*
50  * The Message Type determines how the the message is to be processed.
51  */
52 typedef enum _Com__Seagate__Kinetic__Proto__Message__AuthType {
53  /*
54  * if the message type is unknown, close the connection
55  */
57  /*
58  * This is for normal traffic. Check the HMAC of the command and
59  * if correct, process the command.
60  */
62  /*
63  * device unlock and ISE command. These must come over the TLS connection.
64  * If they do not, close the connection. If it is over
65  * the TLS connection, execute the pin operation.
66  */
68  /*
69  * In the event that the device is going to close the connection, an
70  * unsolicited status will be returned first.
71  */
73  PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(COM__SEAGATE__KINETIC__PROTO__MESSAGE__AUTH_TYPE)
75 /*
76  *enum of status code
77  */
78 typedef enum _Com__Seagate__Kinetic__Proto__Command__Status__StatusCode {
79  /*
80  * Must come first, so default is invalid
81  */
83  /*
84  * for a P2P operation, there was a reason the list was incomplete. This is for items
85  * that were not attempted.
86  */
96  /*
97  * If there are too many requests in the device at this time, requests
98  * will be rejected with this error message. The common response is to
99  * wait and retry the operation with an exponential back-off.
100  */
102  /*
103  * A long operation was started and a timeout happened mid operation. This
104  * does not imply a failure.
105  */
107  /*
108  * A data error happened and either earlyExit was set or the timeout happened.
109  */
111  /*
112  * A data error happened and all possible error recovery operations have been
113  * performed. There is no value to trying this again. If the system has the ability
114  * to determine the correct information, writing the data again can get rid
115  */
117  /*
118  * A TCP connection to the remote peer failed. This is only for the P2P Operation
119  */
121  /*
122  * When the device is full, it returns this error. The background scrubbing may free space,
123  * so this error may go away
124  */
126  /*
127  * In the set security, an HmacAlgorithm was specified as Unknown or there is a protocol
128  * version mis-match
129  */
131  /*
132  * The request is not valid. Subsequent attempts with the same request will return the same code.
133  * Examples: GET does not specify keyValue message, GETKEYRANGE operation does not specify startKey, etc
134  */
136  /*
137  * For P2P Requests, the operation was executed successfully but some nested operations
138  * did not succeed. This indicates that callers should review the status of nested operations.
139  * This status should only be used in the Command > Status, not in the Status messages
140  * of nested P2POperations
141  */
143  /*
144  * If the device is currently locked and can not validate
145  * the hmac. This is returned as an status
146  * and the connection is terminated.
147  */
149  /*
150  * The device was already unlocked. The validity of the
151  * pin was NOT checked. The connection remains open.
152  */
154  /*
155  * The connection is being terminated. Details as to why are
156  * in the message string.
157  */
159  PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(COM__SEAGATE__KINETIC__PROTO__COMMAND__STATUS__STATUS_CODE)
161 typedef enum _Com__Seagate__Kinetic__Proto__Command__GetLog__Type {
162  /*
163  * Must come first, so default is invalid
164  */
174  PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__TYPE)
176 typedef enum _Com__Seagate__Kinetic__Proto__Command__Security__ACL__HMACAlgorithm {
177  /*
178  * Must come first
179  */
181  /*
182  * 0 is reserved; do not use
183  */
184  /*
185  * this is the default
186  */
188  PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(COM__SEAGATE__KINETIC__PROTO__COMMAND__SECURITY__ACL__HMACALGORITHM)
190 typedef enum _Com__Seagate__Kinetic__Proto__Command__Security__ACL__Permission {
191  /*
192  * place holder for backward .proto file compatibility
193  */
195  /*
196  * can read key/values
197  */
199  /*
200  * can write key/values
201  */
204  /*
205  * can do a range
206  */
208  /*
209  * can set up and a device
210  */
212  /*
213  * can do a peer to peer operation
214  */
216  /*
217  * can get log
218  */
220  /*
221  * can set up the security roles of the device
222  */
224  PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(COM__SEAGATE__KINETIC__PROTO__COMMAND__SECURITY__ACL__PERMISSION)
226 typedef enum _Com__Seagate__Kinetic__Proto__Command__PinOperation__PinOpType {
228  /*
229  * The pin will unlock the device
230  */
232  /*
233  * This will lock the device. This includes all
234  * configuration and user data. This operation is
235  * secure from even given physical access and
236  * disassembly of the device.
237  */
239  /*
240  * Erase the device. This may be secure
241  * or not. The implication is that it may be faster
242  * than the secure operation.
243  */
245  /*
246  * Erase the device in a way that will
247  * physical access and disassembly of the device
248  * will not
249  */
251  PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(COM__SEAGATE__KINETIC__PROTO__COMMAND__PIN_OPERATION__PIN_OP_TYPE)
253 typedef enum _Com__Seagate__Kinetic__Proto__Command__Synchronization {
254  /*
255  * Must come first, so default is invalid
256  */
261  PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(COM__SEAGATE__KINETIC__PROTO__COMMAND__SYNCHRONIZATION)
263 typedef enum _Com__Seagate__Kinetic__Proto__Command__Priority {
269  PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(COM__SEAGATE__KINETIC__PROTO__COMMAND__PRIORITY)
271 /*
272  *algorithm
273  */
274 typedef enum _Com__Seagate__Kinetic__Proto__Command__Algorithm {
275  /*
276  * Must come first, so default is invalid
277  */
279  /*
280  * see NIST
281  */
283  /*
284  * see NIST
285  */
287  /*
288  * see NIST. The length of the tag determined the length of the hash
289  */
291  /*
292  * the CRC32 is the standard Ethernet CRC32. See IEEE
293  */
295  /*
296  * The CRC is ...
297  */
299  PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(COM__SEAGATE__KINETIC__PROTO__COMMAND__ALGORITHM)
301 /*
302  *operation code
303  */
304 typedef enum _Com__Seagate__Kinetic__Proto__Command__MessageType {
305  /*
306  * Must come first, so default is invalid
307  */
309  /*
310  *get operation
311  */
314  /*
315  *put operation
316  */
327  /*
328  * 13 and 14 are reserved, do not use
329  */
332  /*
333  * 17, 18, 19, and 20 are reserved, do not use
334  */
341  /*
342  *peer to peer push operation
343  */
350  /*
351  * 33, 34 are reserved
352  */
353  /*
354  * Pin based operations
355  */
358  /*
359  * Media scan is to check that the user data is readable, and
360  * if the end to end integrity is known to the device, if the
361  * end to end integrity field is correct.
362  */
365  /*
366  * This performs optimizations of the media. Things like
367  * defragmentation, compaction, garbage collection, compression
368  * could be things accomplished using the media optimize command.
369  */
372  PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(COM__SEAGATE__KINETIC__PROTO__COMMAND__MESSAGE_TYPE)
374 
375 /* --- messages --- */
376 
377 /*
378  * this is a local message to allow the program to read
379  * the protocol version number by building this message
380  * and then reading the value.
381  */
383 {
384  ProtobufCMessage base;
386 };
388 #define COM__SEAGATE__KINETIC__PROTO__LOCAL__INIT \
389  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__local__descriptor) \
390  , com__seagate__kinetic__proto__local__protocol_version__default_value }
391 
392 
393 /*
394  * This is for normal message to the device
395  * and for responses. These are allowed once the
396  * device is unlocked. The HMAC provides for
397  * authenticity, Integrity and to enforce roles.
398  */
400 {
401  ProtobufCMessage base;
402  /*
403  * The "identity" identifies the requester and the key and algorithm to
404  * be used for hmac.
405  */
406  protobuf_c_boolean has_identity;
407  int64_t identity;
408  protobuf_c_boolean has_hmac;
409  ProtobufCBinaryData hmac;
410 };
411 #define COM__SEAGATE__KINETIC__PROTO__MESSAGE__HMACAUTH__INIT \
412  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__message__hmacauth__descriptor) \
413  , 0,0, 0,{0,NULL} }
414 
415 
416 /*
417  * Pin based authentication for Pin operations.
418  */
420 {
421  ProtobufCMessage base;
422  /*
423  * The pin necessary to make the operations valid
424  */
425  protobuf_c_boolean has_pin;
426  ProtobufCBinaryData pin;
427 };
428 #define COM__SEAGATE__KINETIC__PROTO__MESSAGE__PINAUTH__INIT \
429  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__message__pinauth__descriptor) \
430  , 0,{0,NULL} }
431 
432 
433 /*
434  * THe message is an authorization and command bytes.
435  */
437 {
438  ProtobufCMessage base;
439  /*
440  * Every message must be one of the following types.
441  */
442  protobuf_c_boolean has_authtype;
444  /*
445  * Normal messages
446  */
447  Com__Seagate__Kinetic__Proto__Message__HMACauth *hmacauth;
448  /*
449  * for Pin based operations. These include device unlock and
450  * device erase
451  */
452  Com__Seagate__Kinetic__Proto__Message__PINauth *pinauth;
453  /*
454  * the embedded message providing the request (for HMACauth) and
455  * the response (for all auth types).
456  */
457  protobuf_c_boolean has_commandbytes;
458  ProtobufCBinaryData commandbytes;
459 };
460 #define COM__SEAGATE__KINETIC__PROTO__MESSAGE__INIT \
461  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__message__descriptor) \
462  , 0,0, NULL, NULL, 0,{0,NULL} }
463 
464 
465 /*
466  *message header
467  */
469 {
470  ProtobufCMessage base;
471  /*
472  * "cluster" is the number of the cluster definition. If this is incompatible,
473  * the request is rejected. If it is missing, it is assumed to be 0. (0 allows systems not
474  * using cluster versioning to ignore this field in the header and in the setup.)
475  */
476  protobuf_c_boolean has_clusterversion;
477  int64_t clusterversion;
478  /*
479  * A unique number for this connection between the source and target. On the first request
480  * to the device, this should be the time of day in seconds since 1970. The device can change this
481  * number and the client must continue to use the new number and the number must remain
482  * constant during the session. (See security document).
483  */
484  protobuf_c_boolean has_connectionid;
485  int64_t connectionid;
486  /*
487  * the sequence of this request in this TCP connection. As long as this value is getting larger we have
488  * strong ordering and replay prevention within a session. This combined with the time and connectionID
489  * provides strong ordering between sessions. (See security document).
490  */
491  protobuf_c_boolean has_sequence;
492  int64_t sequence;
493  /*
494  *co-related sequence
495  */
496  protobuf_c_boolean has_acksequence;
497  int64_t acksequence;
498  /*
499  *operation code - put/get/delete/GetLog, etc.
500  */
501  protobuf_c_boolean has_messagetype;
503  /*
504  * Request timeout (in ms). This is the amount of time that this request should take. If this timeout
505  * is triggered, there are three possible results that can be returned.
506  * - SERVICE_BUSY meaning that the request was still on the queue waiting to be executed
507  * - EXPIRED meaning that a long running operation was stopped because the time expired.
508  * - DATA_ERROR meaning that the request was in process, but that the error recovery was not
509  * complete at the time that the time expired
510  */
511  protobuf_c_boolean has_timeout;
512  int64_t timeout;
513  /*
514  * If true, requests will not attempt multi revolution recoveries even if the timeout has not occurred.
515  * In this case the result will be DATA_ERROR. To have the device exhaust all possible error recovery, leave
516  * this field off or set to false, and make sure that the timeout is set to be longer than any possible queue
517  * time and error recovery time. On a disk device, the maximum error recovery time could be seconds.
518  * Once all possible data recovery operations are complete and have not succeeded, PERM_DATA_ERROR will be
519  * returned.
520  */
521  protobuf_c_boolean has_earlyexit;
522  protobuf_c_boolean earlyexit;
523  /*
524  * Priority is a simple integer that determines the priority of this
525  * request. All activity at a higher priority will execute before that
526  * of lower priority traffic. A higher number is higher priority.
527  */
528  protobuf_c_boolean has_priority;
530  /*
531  * A hint of how long a job should run before yielding. Specified in
532  * miliseconds. A value of 0 indicates that the operation can perform one
533  * sub operation and then check to see if there are other sub higher
534  * priority operations. An example of a sub-operation might be a single put
535  * in a P2P operation, etc.
536  */
537  protobuf_c_boolean has_timequanta;
538  int64_t timequanta;
539 };
540 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__HEADER__INIT \
541  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__header__descriptor) \
542  , 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0 }
543 
544 
545 /*
546  *message body
547  */
549 {
550  ProtobufCMessage base;
551  /*
552  *key/value op
553  */
554  Com__Seagate__Kinetic__Proto__Command__KeyValue *keyvalue;
555  /*
556  *range operation
557  */
558  Com__Seagate__Kinetic__Proto__Command__Range *range;
559  /*
560  *set up operation
561  */
562  Com__Seagate__Kinetic__Proto__Command__Setup *setup;
563  /*
564  * Peer to Peer operations.
565  */
566  Com__Seagate__Kinetic__Proto__Command__P2POperation *p2poperation;
567  /*
568  *GetLog
569  */
570  Com__Seagate__Kinetic__Proto__Command__GetLog *getlog;
571  /*
572  *set up security
573  */
574  Com__Seagate__Kinetic__Proto__Command__Security *security;
575  /*
576  * Perform Pin-based operations
577  */
578  Com__Seagate__Kinetic__Proto__Command__PinOperation *pinop;
579 };
580 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__BODY__INIT \
581  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__body__descriptor) \
582  , NULL, NULL, NULL, NULL, NULL, NULL, NULL }
583 
584 
585 /*
586  *operation status
587  */
589 {
590  ProtobufCMessage base;
591  /*
592  *status code
593  */
594  protobuf_c_boolean has_code;
596  /*
597  *status message
598  */
600  /*
601  *optional information comes with status
602  */
603  protobuf_c_boolean has_detailedmessage;
604  ProtobufCBinaryData detailedmessage;
605 };
606 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__STATUS__INIT \
607  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__status__descriptor) \
608  , 0,0, NULL, 0,{0,NULL} }
609 
610 
611 /*
612  *key/value entry operation
613  */
615 {
616  ProtobufCMessage base;
617  /*
618  * On a put or delete, this is the next version that the data will be. The version field is opaque to the
619  * target. (See Atomic operations document)
620  */
621  protobuf_c_boolean has_newversion;
622  ProtobufCBinaryData newversion;
623  /*
624  * On a put or delete, this forces the write to ignore the existing version of existing data (if it exists).
625  */
626  protobuf_c_boolean has_force;
627  protobuf_c_boolean force;
628  /*
629  *entry key
630  */
631  protobuf_c_boolean has_key;
632  ProtobufCBinaryData key;
633  /*
634  *entry version in store
635  */
636  protobuf_c_boolean has_dbversion;
637  ProtobufCBinaryData dbversion;
638  /*
639  * this is the integrity value of the data. This may or may not be in the clear, depending on the algorithm
640  * used.
641  */
642  protobuf_c_boolean has_tag;
643  ProtobufCBinaryData tag;
644  /*
645  * The following is for the protection of the data. If the data is protected with a hash or CRC, then
646  * the algorithm will be negative. If the data protection algorithm is not a standard unkeyed algorithm
647  * then a positive number is used and the device has no idea what the key is. See the discussion of
648  * encrypted key/value store.(See security document).
649  */
650  protobuf_c_boolean has_algorithm;
652  /*
653  * for read operations, this will get all the information about the value except for the
654  * value itself. This is valuable for getting the integrity field or the version without also
655  * having to get the data. If this field is not present, it is as if it is false. For
656  * write or delete operations, if this is set, the command is rejected.
657  */
658  protobuf_c_boolean has_metadataonly;
659  protobuf_c_boolean metadataonly;
660  /*
661  * Synchronization allows the puts and deletes to determine if they are to be
662  * WRITETHROUGH: This request is made persistent before returning. This does not effect any other pending operations.
663  * WRITEBACK: They can be made persistent when the device chooses, or when a subsequent FLUSH is give to the device.
664  * FLUSH: All pending information that has not been written is pushed to the disk and the command that
665  * specifies FLUSH is written last and then returned. All WRITEBACK writes that have received ending
666  * status will be guaranteed to be written before the FLUSH operation is returned completed.
667  */
668  protobuf_c_boolean has_synchronization;
670 };
671 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__KEY_VALUE__INIT \
672  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__key_value__descriptor) \
673  , 0,{0,NULL}, 0,0, 0,{0,NULL}, 0,{0,NULL}, 0,{0,NULL}, 0,0, 0,0, 0,0 }
674 
675 
676 /*
677  *key range op
678  */
680 {
681  ProtobufCMessage base;
682  protobuf_c_boolean has_startkey;
683  ProtobufCBinaryData startkey;
684  protobuf_c_boolean has_endkey;
685  ProtobufCBinaryData endkey;
686  protobuf_c_boolean has_startkeyinclusive;
687  protobuf_c_boolean startkeyinclusive;
688  protobuf_c_boolean has_endkeyinclusive;
689  protobuf_c_boolean endkeyinclusive;
690  /*
691  * The maximum number of keys returned
692  */
693  protobuf_c_boolean has_maxreturned;
694  int32_t maxreturned;
695  /*
696  * The keys are searched for and returned in a reverse order. For instance
697  * if the search is startKey="j", endKey="k", maxReturned=2,
698  * reverse=true and the keys "k0", "k1", "k2" exist
699  * the system will return "k2" and "k1" in that order.
700  */
701  protobuf_c_boolean has_reverse;
702  protobuf_c_boolean reverse;
703  /*
704  *get range response .
705  */
706  size_t n_keys;
707  ProtobufCBinaryData *keys;
708 };
709 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__RANGE__INIT \
710  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__range__descriptor) \
711  , 0,{0,NULL}, 0,{0,NULL}, 0,0, 0,0, 0,0, 0,0, 0,NULL }
712 
713 
714 /*
715  * if any or all of these are fields are included, they are set.
716  * These are persistent options that are retained across power fail and
717  * erased on either PIN erase or PIN secure erase.
718  */
720 {
721  ProtobufCMessage base;
722  /*
723  * The cluster version to be checked. The default if never set is 0.
724  * If this is missing, it is assumed to be unchanged;
725  * This is persistent between boots of the device.
726  */
727  protobuf_c_boolean has_newclusterversion;
729  /*
730  * indicates the presence of a firmware load in the data portion of this
731  * message. The firmware is itself protected on its own for integrity,
732  * authenticity, etc.
733  */
734  protobuf_c_boolean has_firmwaredownload;
735  protobuf_c_boolean firmwaredownload;
736 };
737 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__SETUP__INIT \
738  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__setup__descriptor) \
739  , 0,0, 0,0 }
740 
741 
743 {
744  ProtobufCMessage base;
745  /*
746  * the key of the entry to move
747  */
748  protobuf_c_boolean has_key;
749  ProtobufCBinaryData key;
750  /*
751  * the expected version number in the other machine
752  * the version number will be the version in the stored entry.
753  */
754  protobuf_c_boolean has_version;
755  ProtobufCBinaryData version;
756  /*
757  * to have the moved key have a different final key used.
758  */
759  protobuf_c_boolean has_newkey;
760  ProtobufCBinaryData newkey;
761  /*
762  * force the write ignoring the current key version.
763  */
764  protobuf_c_boolean has_force;
765  protobuf_c_boolean force;
766  /*
767  * returned status
768  */
769  Com__Seagate__Kinetic__Proto__Command__Status *status;
770  /*
771  * an operation to add to this put operation. THis allows the
772  * formation of a pipeline client -> A ->B ->C with the status for all returning
773  * back to the client.
774  */
775  Com__Seagate__Kinetic__Proto__Command__P2POperation *p2pop;
776 };
777 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__P2_POPERATION__OPERATION__INIT \
778  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__p2_poperation__operation__descriptor) \
779  , 0,{0,NULL}, 0,{0,NULL}, 0,{0,NULL}, 0,0, NULL, NULL }
780 
781 
783 {
784  ProtobufCMessage base;
785  char *hostname;
786  protobuf_c_boolean has_port;
787  int32_t port;
788  protobuf_c_boolean has_tls;
789  protobuf_c_boolean tls;
790 };
791 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__P2_POPERATION__PEER__INIT \
792  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__p2_poperation__peer__descriptor) \
793  , NULL, 0,0, 0,0 }
794 
795 
796 /*
797  * P2P operations allow devices to be able to send keys to other devices.
798  * this is either a standalone command or added to a put command.
799  */
801 {
802  ProtobufCMessage base;
803  /*
804  * Describe the target machine
805  */
806  Com__Seagate__Kinetic__Proto__Command__P2POperation__Peer *peer;
807  /*
808  * List of operations to be performed.
809  */
810  size_t n_operation;
811  Com__Seagate__Kinetic__Proto__Command__P2POperation__Operation **operation;
812  /*
813  * Indicates whether all operations have Status SUCCESS
814  * When false, clients should traverse Operation status codes to discover
815  * error cases.
816  * When true, no further error checking should be required.
817  */
819  protobuf_c_boolean allchildoperationssucceeded;
820 };
821 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__P2_POPERATION__INIT \
822  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__p2_poperation__descriptor) \
823  , NULL, 0,NULL, 0,0 }
824 
825 
827 {
828  ProtobufCMessage base;
829  /*
830  * The name of the utilization being reported. These names can be standard and proprietary. The
831  * standard names are "HDA", "EN0" and "EN1". If there are more items that are
832  * being reported, such as processor utilization, can have a descriptive name.
833  */
834  char *name;
835  /*
836  * A number between 0.00 and 1.00. The resolution of this number is up to the
837  * device. 1 means 100% utilized.
838  */
839  protobuf_c_boolean has_value;
840  float value;
841 };
842 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__UTILIZATION__INIT \
843  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__get_log__utilization__descriptor) \
844  , NULL, 0,0 }
845 
846 
848 {
849  ProtobufCMessage base;
850  /*
851  * The name of the temperature being reported. These names can be standard and proprietary. The
852  * standard name is "HDA". If there are more items that are
853  * being reported, such as processor temperature, can have a descriptive name.
854  */
855  char *name;
856  /*
857  * The current temperature in degrees c
858  */
859  protobuf_c_boolean has_current;
860  float current;
861  protobuf_c_boolean has_minimum;
862  float minimum;
863  protobuf_c_boolean has_maximum;
864  float maximum;
865  protobuf_c_boolean has_target;
866  float target;
867 };
868 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__TEMPERATURE__INIT \
869  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__get_log__temperature__descriptor) \
870  , NULL, 0,0, 0,0, 0,0, 0,0 }
871 
872 
873 /*
874  * These capacities are in bytes.
875  */
877 {
878  ProtobufCMessage base;
879  /*
880  * 1-3 are reserved
881  */
882  protobuf_c_boolean has_nominalcapacityinbytes;
884  protobuf_c_boolean has_portionfull;
885  float portionfull;
886 };
887 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__CAPACITY__INIT \
888  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__get_log__capacity__descriptor) \
889  , 0,0, 0,0 }
890 
891 
892 /*
893  * 18, 19 are reserved.
894  */
896 {
897  ProtobufCMessage base;
898  char *name;
899  protobuf_c_boolean has_mac;
900  ProtobufCBinaryData mac;
901  protobuf_c_boolean has_ipv4address;
902  ProtobufCBinaryData ipv4address;
903  protobuf_c_boolean has_ipv6address;
904  ProtobufCBinaryData ipv6address;
905 };
906 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__CONFIGURATION__INTERFACE__INIT \
907  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__get_log__configuration__interface__descriptor) \
908  , NULL, 0,{0,NULL}, 0,{0,NULL}, 0,{0,NULL} }
909 
910 
912 {
913  ProtobufCMessage base;
914  /*
915  * name of the vendor. Should be "Seagate"
916  */
917  char *vendor;
918  /*
919  * The model of the device.
920  * "Simulator" for the simulator.
921  */
922  char *model;
923  /*
924  * Device Serial number (SN)
925  */
926  protobuf_c_boolean has_serialnumber;
927  ProtobufCBinaryData serialnumber;
928  /*
929  * Device world wide name (WWN)
930  */
931  protobuf_c_boolean has_worldwidename;
932  ProtobufCBinaryData worldwidename;
933  /*
934  * This is the vendor specific version of the software on the device in dot notation
935  * if this is not set or ends with "x" this is test code.
936  */
937  char *version;
939  char *sourcehash;
940  /*
941  * This is the version of the protocol (.proto file) that the device uses.
942  * This is not the highest or lowest version that is supported, just
943  * the version that was compiled.
944  */
948  /*
949  * the interfaces for this device. one per interface.
950  */
951  size_t n_interface;
952  Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration__Interface **interface;
953  /*
954  * these are the port numbers for the software
955  */
956  protobuf_c_boolean has_port;
957  int32_t port;
958  protobuf_c_boolean has_tlsport;
959  int32_t tlsport;
960 };
961 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__CONFIGURATION__INIT \
962  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__get_log__configuration__descriptor) \
963  , NULL, NULL, 0,{0,NULL}, 0,{0,NULL}, NULL, NULL, NULL, NULL, NULL, NULL, 0,NULL, 0,0, 0,0 }
964 
965 
966 /*
967  * These numbers start at 0 when the device starts up and never wraps or resets.
968  */
970 {
971  ProtobufCMessage base;
972  protobuf_c_boolean has_messagetype;
974  /*
975  * 2 and 3 are reserved, do not use
976  */
977  protobuf_c_boolean has_count;
978  uint64_t count;
979  /*
980  * This is the sum of the data that is in the data portion. This does not include t
981  * the command description. For P2P operations, this is the amount of data moved between
982  * devices
983  */
984  protobuf_c_boolean has_bytes;
985  uint64_t bytes;
986 };
987 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__STATISTICS__INIT \
988  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__get_log__statistics__descriptor) \
989  , 0,0, 0,0, 0,0 }
990 
991 
993 {
994  ProtobufCMessage base;
995  protobuf_c_boolean has_maxkeysize;
996  uint32_t maxkeysize;
997  protobuf_c_boolean has_maxvaluesize;
998  uint32_t maxvaluesize;
999  protobuf_c_boolean has_maxversionsize;
1000  uint32_t maxversionsize;
1001  protobuf_c_boolean has_maxtagsize;
1002  uint32_t maxtagsize;
1003  protobuf_c_boolean has_maxconnections;
1004  uint32_t maxconnections;
1009  protobuf_c_boolean has_maxmessagesize;
1010  uint32_t maxmessagesize;
1011  protobuf_c_boolean has_maxkeyrangecount;
1013  protobuf_c_boolean has_maxidentitycount;
1015  protobuf_c_boolean has_maxpinsize;
1016  uint32_t maxpinsize;
1017 };
1018 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__LIMITS__INIT \
1019  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__get_log__limits__descriptor) \
1020  , 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0 }
1021 
1022 
1023 /*
1024  * The Device GetLog message is to ask the device to send back the
1025  * log of a certain name in the value field. The limit of each
1026  * log is 1m byte.
1027  * Proprietary names should be prefaced by the vendor name so that name
1028  * collisions do not happen in the future. An example could be names that
1029  * start with “com.WD” would be for Western Digital devices.
1030  * If the name is not found, the get log returns NOT_FOUND.
1031  * There can be only one Device in the list of logs that can be retrieved.!
1032  */
1034 {
1035  ProtobufCMessage base;
1036  protobuf_c_boolean has_name;
1037  ProtobufCBinaryData name;
1038 };
1039 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__DEVICE__INIT \
1040  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__get_log__device__descriptor) \
1041  , 0,{0,NULL} }
1042 
1043 
1044 /*
1045  *get log
1046  */
1048 {
1049  ProtobufCMessage base;
1050  size_t n_types;
1053  Com__Seagate__Kinetic__Proto__Command__GetLog__Utilization **utilizations;
1055  Com__Seagate__Kinetic__Proto__Command__GetLog__Temperature **temperatures;
1056  Com__Seagate__Kinetic__Proto__Command__GetLog__Capacity *capacity;
1057  Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration *configuration;
1059  Com__Seagate__Kinetic__Proto__Command__GetLog__Statistics **statistics;
1060  protobuf_c_boolean has_messages;
1061  ProtobufCBinaryData messages;
1062  Com__Seagate__Kinetic__Proto__Command__GetLog__Limits *limits;
1063  Com__Seagate__Kinetic__Proto__Command__GetLog__Device *device;
1064 };
1065 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__INIT \
1066  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__get_log__descriptor) \
1067  , 0,NULL, 0,NULL, 0,NULL, NULL, NULL, 0,NULL, 0,{0,NULL}, NULL, NULL }
1068 
1069 
1071 {
1072  ProtobufCMessage base;
1073  protobuf_c_boolean has_offset;
1074  int64_t offset;
1075  protobuf_c_boolean has_value;
1076  ProtobufCBinaryData value;
1077  /*
1078  * one per role
1079  */
1082  /*
1083  * This is only allowed over the the TLS connection
1084  */
1085  protobuf_c_boolean has_tlsrequired;
1086  protobuf_c_boolean tlsrequired;
1087 };
1088 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__SECURITY__ACL__SCOPE__INIT \
1089  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__security__acl__scope__descriptor) \
1090  , 0,0, 0,{0,NULL}, 0,NULL, 0,0 }
1091 
1092 
1093 /*
1094  */
1096 {
1097  ProtobufCMessage base;
1098  protobuf_c_boolean has_identity;
1099  int64_t identity;
1100  /*
1101  * the HMAC key
1102  */
1103  protobuf_c_boolean has_key;
1104  ProtobufCBinaryData key;
1105  protobuf_c_boolean has_hmacalgorithm;
1107  /*
1108  * value that must be in the key for read, write, range requests. If none are specified
1109  * then no checking occurs. If one or more is specified, one must match or the request
1110  * is rejected
1111  */
1112  size_t n_scope;
1113  Com__Seagate__Kinetic__Proto__Command__Security__ACL__Scope **scope;
1114  /*
1115  * The maxPriority is checked against the header priority and range
1116  * priority (if present) fields. The priority must be greater than
1117  * or equal to this maxPriority field.
1118  */
1119  protobuf_c_boolean has_maxpriority;
1121 };
1122 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__SECURITY__ACL__INIT \
1123  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__security__acl__descriptor) \
1124  , 0,0, 0,{0,NULL}, 0,0, 0,NULL, 0,0 }
1125 
1126 
1127 /*
1128  * These are persistent options that are retained across power fail and
1129  * erased on either PIN erase or PIN secure erase.
1130  */
1132 {
1133  ProtobufCMessage base;
1134  /*
1135  * one per identity
1136  */
1137  size_t n_acl;
1138  Com__Seagate__Kinetic__Proto__Command__Security__ACL **acl;
1139  /*
1140  * Set the lock and erase pins.
1141  */
1142  protobuf_c_boolean has_oldlockpin;
1143  ProtobufCBinaryData oldlockpin;
1144  protobuf_c_boolean has_newlockpin;
1145  ProtobufCBinaryData newlockpin;
1146  protobuf_c_boolean has_olderasepin;
1147  ProtobufCBinaryData olderasepin;
1148  protobuf_c_boolean has_newerasepin;
1149  ProtobufCBinaryData newerasepin;
1150 };
1151 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__SECURITY__INIT \
1152  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__security__descriptor) \
1153  , 0,NULL, 0,{0,NULL}, 0,{0,NULL}, 0,{0,NULL}, 0,{0,NULL} }
1154 
1155 
1156 /*
1157  * Pin Operations are used for special commands that are valid when the device
1158  * is locked or to be locked. These are unlock, lock and erase.
1159  * This must come over the TLS connection to protect the confidentiality and
1160  * integrity. This operations must be used with PinAuth.
1161  */
1163 {
1164  ProtobufCMessage base;
1165  protobuf_c_boolean has_pinoptype;
1167 };
1168 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__PIN_OPERATION__INIT \
1169  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__pin_operation__descriptor) \
1170  , 0,0 }
1171 
1172 
1174 {
1175  ProtobufCMessage base;
1176  /*
1177  *message header
1178  */
1179  Com__Seagate__Kinetic__Proto__Command__Header *header;
1180  /*
1181  *message body
1182  */
1183  Com__Seagate__Kinetic__Proto__Command__Body *body;
1184  /*
1185  *operation status
1186  */
1187  Com__Seagate__Kinetic__Proto__Command__Status *status;
1188 };
1189 #define COM__SEAGATE__KINETIC__PROTO__COMMAND__INIT \
1190  { PROTOBUF_C_MESSAGE_INIT (&com__seagate__kinetic__proto__command__descriptor) \
1191  , NULL, NULL, NULL }
1192 
1193 
1194 /* Com__Seagate__Kinetic__Proto__Local methods */
1198  (const Com__Seagate__Kinetic__Proto__Local *message);
1200  (const Com__Seagate__Kinetic__Proto__Local *message,
1201  uint8_t *out);
1203  (const Com__Seagate__Kinetic__Proto__Local *message,
1204  ProtobufCBuffer *buffer);
1207  (ProtobufCAllocator *allocator,
1208  size_t len,
1209  const uint8_t *data);
1212  ProtobufCAllocator *allocator);
1213 /* Com__Seagate__Kinetic__Proto__Message__HMACauth methods */
1215  (Com__Seagate__Kinetic__Proto__Message__HMACauth *message);
1216 /* Com__Seagate__Kinetic__Proto__Message__PINauth methods */
1218  (Com__Seagate__Kinetic__Proto__Message__PINauth *message);
1219 /* Com__Seagate__Kinetic__Proto__Message methods */
1221  (Com__Seagate__Kinetic__Proto__Message *message);
1223  (const Com__Seagate__Kinetic__Proto__Message *message);
1225  (const Com__Seagate__Kinetic__Proto__Message *message,
1226  uint8_t *out);
1228  (const Com__Seagate__Kinetic__Proto__Message *message,
1229  ProtobufCBuffer *buffer);
1230 Com__Seagate__Kinetic__Proto__Message *
1232  (ProtobufCAllocator *allocator,
1233  size_t len,
1234  const uint8_t *data);
1236  (Com__Seagate__Kinetic__Proto__Message *message,
1237  ProtobufCAllocator *allocator);
1238 /* Com__Seagate__Kinetic__Proto__Command__Header methods */
1240  (Com__Seagate__Kinetic__Proto__Command__Header *message);
1241 /* Com__Seagate__Kinetic__Proto__Command__Body methods */
1243  (Com__Seagate__Kinetic__Proto__Command__Body *message);
1244 /* Com__Seagate__Kinetic__Proto__Command__Status methods */
1246  (Com__Seagate__Kinetic__Proto__Command__Status *message);
1247 /* Com__Seagate__Kinetic__Proto__Command__KeyValue methods */
1249  (Com__Seagate__Kinetic__Proto__Command__KeyValue *message);
1250 /* Com__Seagate__Kinetic__Proto__Command__Range methods */
1252  (Com__Seagate__Kinetic__Proto__Command__Range *message);
1253 /* Com__Seagate__Kinetic__Proto__Command__Setup methods */
1255  (Com__Seagate__Kinetic__Proto__Command__Setup *message);
1256 /* Com__Seagate__Kinetic__Proto__Command__P2POperation__Operation methods */
1258  (Com__Seagate__Kinetic__Proto__Command__P2POperation__Operation *message);
1259 /* Com__Seagate__Kinetic__Proto__Command__P2POperation__Peer methods */
1261  (Com__Seagate__Kinetic__Proto__Command__P2POperation__Peer *message);
1262 /* Com__Seagate__Kinetic__Proto__Command__P2POperation methods */
1264  (Com__Seagate__Kinetic__Proto__Command__P2POperation *message);
1265 /* Com__Seagate__Kinetic__Proto__Command__GetLog__Utilization methods */
1267  (Com__Seagate__Kinetic__Proto__Command__GetLog__Utilization *message);
1268 /* Com__Seagate__Kinetic__Proto__Command__GetLog__Temperature methods */
1270  (Com__Seagate__Kinetic__Proto__Command__GetLog__Temperature *message);
1271 /* Com__Seagate__Kinetic__Proto__Command__GetLog__Capacity methods */
1273  (Com__Seagate__Kinetic__Proto__Command__GetLog__Capacity *message);
1274 /* Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration__Interface methods */
1276  (Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration__Interface *message);
1277 /* Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration methods */
1279  (Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration *message);
1280 /* Com__Seagate__Kinetic__Proto__Command__GetLog__Statistics methods */
1282  (Com__Seagate__Kinetic__Proto__Command__GetLog__Statistics *message);
1283 /* Com__Seagate__Kinetic__Proto__Command__GetLog__Limits methods */
1285  (Com__Seagate__Kinetic__Proto__Command__GetLog__Limits *message);
1286 /* Com__Seagate__Kinetic__Proto__Command__GetLog__Device methods */
1288  (Com__Seagate__Kinetic__Proto__Command__GetLog__Device *message);
1289 /* Com__Seagate__Kinetic__Proto__Command__GetLog methods */
1291  (Com__Seagate__Kinetic__Proto__Command__GetLog *message);
1292 /* Com__Seagate__Kinetic__Proto__Command__Security__ACL__Scope methods */
1294  (Com__Seagate__Kinetic__Proto__Command__Security__ACL__Scope *message);
1295 /* Com__Seagate__Kinetic__Proto__Command__Security__ACL methods */
1297  (Com__Seagate__Kinetic__Proto__Command__Security__ACL *message);
1298 /* Com__Seagate__Kinetic__Proto__Command__Security methods */
1300  (Com__Seagate__Kinetic__Proto__Command__Security *message);
1301 /* Com__Seagate__Kinetic__Proto__Command__PinOperation methods */
1303  (Com__Seagate__Kinetic__Proto__Command__PinOperation *message);
1304 /* Com__Seagate__Kinetic__Proto__Command methods */
1306  (Com__Seagate__Kinetic__Proto__Command *message);
1308  (const Com__Seagate__Kinetic__Proto__Command *message);
1310  (const Com__Seagate__Kinetic__Proto__Command *message,
1311  uint8_t *out);
1313  (const Com__Seagate__Kinetic__Proto__Command *message,
1314  ProtobufCBuffer *buffer);
1315 Com__Seagate__Kinetic__Proto__Command *
1317  (ProtobufCAllocator *allocator,
1318  size_t len,
1319  const uint8_t *data);
1321  (Com__Seagate__Kinetic__Proto__Command *message,
1322  ProtobufCAllocator *allocator);
1323 /* --- per-message closures --- */
1324 
1327  void *closure_data);
1329  (const Com__Seagate__Kinetic__Proto__Message__HMACauth *message,
1330  void *closure_data);
1332  (const Com__Seagate__Kinetic__Proto__Message__PINauth *message,
1333  void *closure_data);
1335  (const Com__Seagate__Kinetic__Proto__Message *message,
1336  void *closure_data);
1338  (const Com__Seagate__Kinetic__Proto__Command__Header *message,
1339  void *closure_data);
1341  (const Com__Seagate__Kinetic__Proto__Command__Body *message,
1342  void *closure_data);
1344  (const Com__Seagate__Kinetic__Proto__Command__Status *message,
1345  void *closure_data);
1347  (const Com__Seagate__Kinetic__Proto__Command__KeyValue *message,
1348  void *closure_data);
1350  (const Com__Seagate__Kinetic__Proto__Command__Range *message,
1351  void *closure_data);
1353  (const Com__Seagate__Kinetic__Proto__Command__Setup *message,
1354  void *closure_data);
1356  (const Com__Seagate__Kinetic__Proto__Command__P2POperation__Operation *message,
1357  void *closure_data);
1359  (const Com__Seagate__Kinetic__Proto__Command__P2POperation__Peer *message,
1360  void *closure_data);
1362  (const Com__Seagate__Kinetic__Proto__Command__P2POperation *message,
1363  void *closure_data);
1365  (const Com__Seagate__Kinetic__Proto__Command__GetLog__Utilization *message,
1366  void *closure_data);
1368  (const Com__Seagate__Kinetic__Proto__Command__GetLog__Temperature *message,
1369  void *closure_data);
1371  (const Com__Seagate__Kinetic__Proto__Command__GetLog__Capacity *message,
1372  void *closure_data);
1374  (const Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration__Interface *message,
1375  void *closure_data);
1377  (const Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration *message,
1378  void *closure_data);
1380  (const Com__Seagate__Kinetic__Proto__Command__GetLog__Statistics *message,
1381  void *closure_data);
1383  (const Com__Seagate__Kinetic__Proto__Command__GetLog__Limits *message,
1384  void *closure_data);
1386  (const Com__Seagate__Kinetic__Proto__Command__GetLog__Device *message,
1387  void *closure_data);
1389  (const Com__Seagate__Kinetic__Proto__Command__GetLog *message,
1390  void *closure_data);
1392  (const Com__Seagate__Kinetic__Proto__Command__Security__ACL__Scope *message,
1393  void *closure_data);
1395  (const Com__Seagate__Kinetic__Proto__Command__Security__ACL *message,
1396  void *closure_data);
1398  (const Com__Seagate__Kinetic__Proto__Command__Security *message,
1399  void *closure_data);
1401  (const Com__Seagate__Kinetic__Proto__Command__PinOperation *message,
1402  void *closure_data);
1404  (const Com__Seagate__Kinetic__Proto__Command *message,
1405  void *closure_data);
1406 
1407 /* --- services --- */
1408 
1409 
1410 /* --- descriptors --- */
1411 
1412 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__local__descriptor;
1413 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__message__descriptor;
1414 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__message__hmacauth__descriptor;
1415 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__message__pinauth__descriptor;
1416 extern const ProtobufCEnumDescriptor com__seagate__kinetic__proto__message__auth_type__descriptor;
1417 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__descriptor;
1418 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__header__descriptor;
1419 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__body__descriptor;
1420 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__status__descriptor;
1422 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__key_value__descriptor;
1423 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__range__descriptor;
1424 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__setup__descriptor;
1425 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__p2_poperation__descriptor;
1427 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__p2_poperation__peer__descriptor;
1428 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__descriptor;
1429 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__utilization__descriptor;
1430 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__temperature__descriptor;
1431 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__capacity__descriptor;
1434 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__statistics__descriptor;
1435 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__limits__descriptor;
1436 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__device__descriptor;
1437 extern const ProtobufCEnumDescriptor com__seagate__kinetic__proto__command__get_log__type__descriptor;
1438 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__security__descriptor;
1439 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__security__acl__descriptor;
1440 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__security__acl__scope__descriptor;
1443 extern const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__pin_operation__descriptor;
1445 extern const ProtobufCEnumDescriptor com__seagate__kinetic__proto__command__synchronization__descriptor;
1446 extern const ProtobufCEnumDescriptor com__seagate__kinetic__proto__command__priority__descriptor;
1447 extern const ProtobufCEnumDescriptor com__seagate__kinetic__proto__command__algorithm__descriptor;
1448 extern const ProtobufCEnumDescriptor com__seagate__kinetic__proto__command__message_type__descriptor;
1449 
1450 PROTOBUF_C__END_DECLS
1451 
1452 
1453 #endif /* PROTOBUF_C_kinetic_2eproto__INCLUDED */
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__utilization__descriptor
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__descriptor
Com__Seagate__Kinetic__Proto__Command__MessageType
Definition: kinetic.pb-c.h:304
const ProtobufCEnumDescriptor com__seagate__kinetic__proto__command__get_log__type__descriptor
Com__Seagate__Kinetic__Proto__Command__Security__ACL__Permission
Definition: kinetic.pb-c.h:190
Com__Seagate__Kinetic__Proto__Command__Range * range
Definition: kinetic.pb-c.h:558
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__p2_poperation__operation__descriptor
void com__seagate__kinetic__proto__command__status__init(Com__Seagate__Kinetic__Proto__Command__Status *message)
Definition: kinetic.pb-c.c:121
void(* Com__Seagate__Kinetic__Proto__Command__KeyValue_Closure)(const Com__Seagate__Kinetic__Proto__Command__KeyValue *message, void *closure_data)
void(* Com__Seagate__Kinetic__Proto__Command__Header_Closure)(const Com__Seagate__Kinetic__Proto__Command__Header *message, void *closure_data)
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__range__descriptor
Com__Seagate__Kinetic__Proto__Command__GetLog__Device * device
void(* Com__Seagate__Kinetic__Proto__Command__Range_Closure)(const Com__Seagate__Kinetic__Proto__Command__Range *message, void *closure_data)
Com__Seagate__Kinetic__Proto__Command__Algorithm algorithm
Definition: kinetic.pb-c.h:651
const ProtobufCEnumDescriptor com__seagate__kinetic__proto__command__synchronization__descriptor
size_t com__seagate__kinetic__proto__message__pack_to_buffer(const Com__Seagate__Kinetic__Proto__Message *message, ProtobufCBuffer *buffer)
Definition: kinetic.pb-c.c:85
Com__Seagate__Kinetic__Proto__Command__Security__ACL ** acl
void com__seagate__kinetic__proto__command__body__init(Com__Seagate__Kinetic__Proto__Command__Body *message)
Definition: kinetic.pb-c.c:115
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__body__descriptor
Definition: kinetic.pb-c.c:768
Com__Seagate__Kinetic__Proto__Command__Header * header
void(* Com__Seagate__Kinetic__Proto__Command__Closure)(const Com__Seagate__Kinetic__Proto__Command *message, void *closure_data)
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__local__descriptor
Definition: kinetic.pb-c.c:307
Com__Seagate__Kinetic__Proto__Command__Body * body
void(* Com__Seagate__Kinetic__Proto__Command__GetLog__Statistics_Closure)(const Com__Seagate__Kinetic__Proto__Command__GetLog__Statistics *message, void *closure_data)
Com__Seagate__Kinetic__Proto__Command__Setup * setup
Definition: kinetic.pb-c.h:562
void com__seagate__kinetic__proto__command__get_log__utilization__init(Com__Seagate__Kinetic__Proto__Command__GetLog__Utilization *message)
Definition: kinetic.pb-c.c:163
void(* Com__Seagate__Kinetic__Proto__Command__Security__ACL__Closure)(const Com__Seagate__Kinetic__Proto__Command__Security__ACL *message, void *closure_data)
size_t com__seagate__kinetic__proto__local__get_packed_size(const Com__Seagate__Kinetic__Proto__Local *message)
Definition: kinetic.pb-c.c:17
Com__Seagate__Kinetic__Proto__Command__Algorithm
Definition: kinetic.pb-c.h:274
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__p2_poperation__descriptor
void com__seagate__kinetic__proto__command__key_value__init(Com__Seagate__Kinetic__Proto__Command__KeyValue *message)
Definition: kinetic.pb-c.c:127
Com__Seagate__Kinetic__Proto__Command__Synchronization
Definition: kinetic.pb-c.h:253
const ProtobufCEnumDescriptor com__seagate__kinetic__proto__command__priority__descriptor
Com__Seagate__Kinetic__Proto__Message__AuthType
Definition: kinetic.pb-c.h:52
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__message__hmacauth__descriptor
Definition: kinetic.pb-c.c:358
void(* Com__Seagate__Kinetic__Proto__Command__Status__Closure)(const Com__Seagate__Kinetic__Proto__Command__Status *message, void *closure_data)
Com__Seagate__Kinetic__Proto__Command__Security__ACL__HMACAlgorithm hmacalgorithm
Com__Seagate__Kinetic__Proto__Message * com__seagate__kinetic__proto__message__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)
Definition: kinetic.pb-c.c:93
Com__Seagate__Kinetic__Proto__Command__PinOperation * pinop
Definition: kinetic.pb-c.h:578
void com__seagate__kinetic__proto__command__get_log__init(Com__Seagate__Kinetic__Proto__Command__GetLog *message)
Definition: kinetic.pb-c.c:211
void(* Com__Seagate__Kinetic__Proto__Command__GetLog__Utilization_Closure)(const Com__Seagate__Kinetic__Proto__Command__GetLog__Utilization *message, void *closure_data)
void(* Com__Seagate__Kinetic__Proto__Command__P2POperation__Operation_Closure)(const Com__Seagate__Kinetic__Proto__Command__P2POperation__Operation *message, void *closure_data)
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__security__acl__scope__descriptor
void(* Com__Seagate__Kinetic__Proto__Command__Body_Closure)(const Com__Seagate__Kinetic__Proto__Command__Body *message, void *closure_data)
void com__seagate__kinetic__proto__command__pin_operation__init(Com__Seagate__Kinetic__Proto__Command__PinOperation *message)
Definition: kinetic.pb-c.c:235
Com__Seagate__Kinetic__Proto__Command__GetLog * getlog
Definition: kinetic.pb-c.h:570
void(* Com__Seagate__Kinetic__Proto__Command__P2POperation_Closure)(const Com__Seagate__Kinetic__Proto__Command__P2POperation *message, void *closure_data)
void(* Com__Seagate__Kinetic__Proto__Message__HMACauth_Closure)(const Com__Seagate__Kinetic__Proto__Message__HMACauth *message, void *closure_data)
void(* Com__Seagate__Kinetic__Proto__Command__Setup_Closure)(const Com__Seagate__Kinetic__Proto__Command__Setup *message, void *closure_data)
const ProtobufCEnumDescriptor com__seagate__kinetic__proto__command__status__status_code__descriptor
Definition: kinetic.pb-c.c:836
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__capacity__descriptor
void(* Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration_Closure)(const Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration *message, void *closure_data)
const ProtobufCEnumDescriptor com__seagate__kinetic__proto__command__pin_operation__pin_op_type__descriptor
void com__seagate__kinetic__proto__message__hmacauth__init(Com__Seagate__Kinetic__Proto__Message__HMACauth *message)
Definition: kinetic.pb-c.c:54
Com__Seagate__Kinetic__Proto__Command__PinOperation__PinOpType
Definition: kinetic.pb-c.h:226
const ProtobufCEnumDescriptor com__seagate__kinetic__proto__command__security__acl__hmacalgorithm__descriptor
void com__seagate__kinetic__proto__command__get_log__temperature__init(Com__Seagate__Kinetic__Proto__Command__GetLog__Temperature *message)
Definition: kinetic.pb-c.c:169
size_t com__seagate__kinetic__proto__message__pack(const Com__Seagate__Kinetic__Proto__Message *message, uint8_t *out)
Definition: kinetic.pb-c.c:78
Com__Seagate__Kinetic__Proto__Command__Priority
Definition: kinetic.pb-c.h:263
Com__Seagate__Kinetic__Proto__Command__GetLog__Limits * limits
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__pin_operation__descriptor
void com__seagate__kinetic__proto__command__get_log__configuration__init(Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration *message)
Definition: kinetic.pb-c.c:187
void com__seagate__kinetic__proto__command__free_unpacked(Com__Seagate__Kinetic__Proto__Command *message, ProtobufCAllocator *allocator)
Definition: kinetic.pb-c.c:277
Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration * configuration
Com__Seagate__Kinetic__Proto__Command__GetLog__Type
Definition: kinetic.pb-c.h:161
void com__seagate__kinetic__proto__command__p2_poperation__operation__init(Com__Seagate__Kinetic__Proto__Command__P2POperation__Operation *message)
Definition: kinetic.pb-c.c:145
Com__Seagate__Kinetic__Proto__Command * com__seagate__kinetic__proto__command__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)
Definition: kinetic.pb-c.c:268
void com__seagate__kinetic__proto__local__init(Com__Seagate__Kinetic__Proto__Local *message)
Definition: kinetic.pb-c.c:11
typedefPROTOBUF_C__BEGIN_DECLS struct _Com__Seagate__Kinetic__Proto__Local Com__Seagate__Kinetic__Proto__Local
Definition: kinetic.pb-c.h:18
Com__Seagate__Kinetic__Proto__Command__GetLog__Utilization ** utilizations
Com__Seagate__Kinetic__Proto__Command__GetLog__Type * types
Com__Seagate__Kinetic__Proto__Command__GetLog__Temperature ** temperatures
Com__Seagate__Kinetic__Proto__Command__GetLog__Statistics ** statistics
void(* Com__Seagate__Kinetic__Proto__Command__GetLog__Closure)(const Com__Seagate__Kinetic__Proto__Command__GetLog *message, void *closure_data)
void com__seagate__kinetic__proto__command__security__acl__init(Com__Seagate__Kinetic__Proto__Command__Security__ACL *message)
Definition: kinetic.pb-c.c:223
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__device__descriptor
Com__Seagate__Kinetic__Proto__Message__HMACauth * hmacauth
Definition: kinetic.pb-c.h:447
void com__seagate__kinetic__proto__command__get_log__statistics__init(Com__Seagate__Kinetic__Proto__Command__GetLog__Statistics *message)
Definition: kinetic.pb-c.c:193
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__temperature__descriptor
Com__Seagate__Kinetic__Proto__Command__Status * status
Definition: kinetic.pb-c.h:769
void com__seagate__kinetic__proto__command__p2_poperation__peer__init(Com__Seagate__Kinetic__Proto__Command__P2POperation__Peer *message)
Definition: kinetic.pb-c.c:151
void(* Com__Seagate__Kinetic__Proto__Command__Security_Closure)(const Com__Seagate__Kinetic__Proto__Command__Security *message, void *closure_data)
Com__Seagate__Kinetic__Proto__Command__Status__StatusCode code
Definition: kinetic.pb-c.h:595
void com__seagate__kinetic__proto__command__get_log__configuration__interface__init(Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration__Interface *message)
Definition: kinetic.pb-c.c:181
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__header__descriptor
Definition: kinetic.pb-c.c:651
void com__seagate__kinetic__proto__message__init(Com__Seagate__Kinetic__Proto__Message *message)
Definition: kinetic.pb-c.c:66
Com__Seagate__Kinetic__Proto__Command__P2POperation__Operation ** operation
Definition: kinetic.pb-c.h:811
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__configuration__descriptor
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__message__descriptor
Definition: kinetic.pb-c.c:505
Com__Seagate__Kinetic__Proto__Command__PinOperation__PinOpType pinoptype
Com__Seagate__Kinetic__Proto__Command__Security__ACL__Scope ** scope
Com__Seagate__Kinetic__Proto__Command__MessageType messagetype
Definition: kinetic.pb-c.h:502
Com__Seagate__Kinetic__Proto__Command__Security * security
Definition: kinetic.pb-c.h:574
const ProtobufCEnumDescriptor com__seagate__kinetic__proto__message__auth_type__descriptor
Definition: kinetic.pb-c.c:428
size_t com__seagate__kinetic__proto__message__get_packed_size(const Com__Seagate__Kinetic__Proto__Message *message)
Definition: kinetic.pb-c.c:72
Com__Seagate__Kinetic__Proto__Command__Security__ACL__HMACAlgorithm
Definition: kinetic.pb-c.h:176
void(* Com__Seagate__Kinetic__Proto__Command__PinOperation_Closure)(const Com__Seagate__Kinetic__Proto__Command__PinOperation *message, void *closure_data)
Com__Seagate__Kinetic__Proto__Command__MessageType messagetype
Definition: kinetic.pb-c.h:973
void com__seagate__kinetic__proto__command__setup__init(Com__Seagate__Kinetic__Proto__Command__Setup *message)
Definition: kinetic.pb-c.c:139
void(* Com__Seagate__Kinetic__Proto__Command__GetLog__Limits_Closure)(const Com__Seagate__Kinetic__Proto__Command__GetLog__Limits *message, void *closure_data)
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__security__acl__descriptor
void com__seagate__kinetic__proto__local__free_unpacked(Com__Seagate__Kinetic__Proto__Local *message, ProtobufCAllocator *allocator)
Definition: kinetic.pb-c.c:47
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__security__descriptor
Com__Seagate__Kinetic__Proto__Command__KeyValue * keyvalue
Definition: kinetic.pb-c.h:554
Com__Seagate__Kinetic__Proto__Message__PINauth * pinauth
Definition: kinetic.pb-c.h:452
void(* Com__Seagate__Kinetic__Proto__Message_Closure)(const Com__Seagate__Kinetic__Proto__Message *message, void *closure_data)
void com__seagate__kinetic__proto__message__free_unpacked(Com__Seagate__Kinetic__Proto__Message *message, ProtobufCAllocator *allocator)
Definition: kinetic.pb-c.c:102
Com__Seagate__Kinetic__Proto__Command__P2POperation__Peer * peer
Definition: kinetic.pb-c.h:806
void com__seagate__kinetic__proto__command__security__acl__scope__init(Com__Seagate__Kinetic__Proto__Command__Security__ACL__Scope *message)
Definition: kinetic.pb-c.c:217
Com__Seagate__Kinetic__Proto__Command__GetLog__Capacity * capacity
const ProtobufCEnumDescriptor com__seagate__kinetic__proto__command__security__acl__permission__descriptor
Com__Seagate__Kinetic__Proto__Command__Synchronization synchronization
Definition: kinetic.pb-c.h:669
void com__seagate__kinetic__proto__command__p2_poperation__init(Com__Seagate__Kinetic__Proto__Command__P2POperation *message)
Definition: kinetic.pb-c.c:157
void(* Com__Seagate__Kinetic__Proto__Command__Security__ACL__Scope_Closure)(const Com__Seagate__Kinetic__Proto__Command__Security__ACL__Scope *message, void *closure_data)
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__descriptor
Com__Seagate__Kinetic__Proto__Command__Status * status
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__configuration__interface__descriptor
void(* Com__Seagate__Kinetic__Proto__Command__P2POperation__Peer_Closure)(const Com__Seagate__Kinetic__Proto__Command__P2POperation__Peer *message, void *closure_data)
void(* Com__Seagate__Kinetic__Proto__Local_Closure)(const Com__Seagate__Kinetic__Proto__Local *message, void *closure_data)
Com__Seagate__Kinetic__Proto__Command__P2POperation * p2poperation
Definition: kinetic.pb-c.h:566
void com__seagate__kinetic__proto__command__get_log__limits__init(Com__Seagate__Kinetic__Proto__Command__GetLog__Limits *message)
Definition: kinetic.pb-c.c:199
Com__Seagate__Kinetic__Proto__Command__P2POperation * p2pop
Definition: kinetic.pb-c.h:775
Com__Seagate__Kinetic__Proto__Command__Security__ACL__Permission * permission
void(* Com__Seagate__Kinetic__Proto__Command__GetLog__Temperature_Closure)(const Com__Seagate__Kinetic__Proto__Command__GetLog__Temperature *message, void *closure_data)
size_t com__seagate__kinetic__proto__local__pack_to_buffer(const Com__Seagate__Kinetic__Proto__Local *message, ProtobufCBuffer *buffer)
Definition: kinetic.pb-c.c:30
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__key_value__descriptor
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__message__pinauth__descriptor
Definition: kinetic.pb-c.c:396
void com__seagate__kinetic__proto__command__header__init(Com__Seagate__Kinetic__Proto__Command__Header *message)
Definition: kinetic.pb-c.c:109
Com__Seagate__Kinetic__Proto__Command__Priority priority
Definition: kinetic.pb-c.h:529
Com__Seagate__Kinetic__Proto__Local * com__seagate__kinetic__proto__local__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)
Definition: kinetic.pb-c.c:38
size_t com__seagate__kinetic__proto__local__pack(const Com__Seagate__Kinetic__Proto__Local *message, uint8_t *out)
Definition: kinetic.pb-c.c:23
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__limits__descriptor
void(* Com__Seagate__Kinetic__Proto__Command__GetLog__Capacity_Closure)(const Com__Seagate__Kinetic__Proto__Command__GetLog__Capacity *message, void *closure_data)
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__status__descriptor
Definition: kinetic.pb-c.c:900
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__get_log__statistics__descriptor
const ProtobufCEnumDescriptor com__seagate__kinetic__proto__command__message_type__descriptor
void com__seagate__kinetic__proto__command__get_log__device__init(Com__Seagate__Kinetic__Proto__Command__GetLog__Device *message)
Definition: kinetic.pb-c.c:205
const ProtobufCEnumDescriptor com__seagate__kinetic__proto__command__algorithm__descriptor
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__setup__descriptor
void(* Com__Seagate__Kinetic__Proto__Command__GetLog__Device_Closure)(const Com__Seagate__Kinetic__Proto__Command__GetLog__Device *message, void *closure_data)
const ProtobufCMessageDescriptor com__seagate__kinetic__proto__command__p2_poperation__peer__descriptor
void com__seagate__kinetic__proto__command__init(Com__Seagate__Kinetic__Proto__Command *message)
Definition: kinetic.pb-c.c:241
char com__seagate__kinetic__proto__local__protocol_version__default_value[]
Definition: kinetic.pb-c.c:283
Com__Seagate__Kinetic__Proto__Message__AuthType authtype
Definition: kinetic.pb-c.h:443
size_t com__seagate__kinetic__proto__command__get_packed_size(const Com__Seagate__Kinetic__Proto__Command *message)
Definition: kinetic.pb-c.c:247
Com__Seagate__Kinetic__Proto__Command__Status__StatusCode
Definition: kinetic.pb-c.h:78
void com__seagate__kinetic__proto__command__range__init(Com__Seagate__Kinetic__Proto__Command__Range *message)
Definition: kinetic.pb-c.c:133
void(* Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration__Interface_Closure)(const Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration__Interface *message, void *closure_data)
void com__seagate__kinetic__proto__command__security__init(Com__Seagate__Kinetic__Proto__Command__Security *message)
Definition: kinetic.pb-c.c:229
Com__Seagate__Kinetic__Proto__Command__Priority maxpriority
size_t com__seagate__kinetic__proto__command__pack(const Com__Seagate__Kinetic__Proto__Command *message, uint8_t *out)
Definition: kinetic.pb-c.c:253
void com__seagate__kinetic__proto__message__pinauth__init(Com__Seagate__Kinetic__Proto__Message__PINauth *message)
Definition: kinetic.pb-c.c:60
void com__seagate__kinetic__proto__command__get_log__capacity__init(Com__Seagate__Kinetic__Proto__Command__GetLog__Capacity *message)
Definition: kinetic.pb-c.c:175
void(* Com__Seagate__Kinetic__Proto__Message__PINauth_Closure)(const Com__Seagate__Kinetic__Proto__Message__PINauth *message, void *closure_data)
size_t com__seagate__kinetic__proto__command__pack_to_buffer(const Com__Seagate__Kinetic__Proto__Command *message, ProtobufCBuffer *buffer)
Definition: kinetic.pb-c.c:260
Com__Seagate__Kinetic__Proto__Command__GetLog__Configuration__Interface ** interface
Definition: kinetic.pb-c.h:952