00001 #ifndef __XPROTOCOL_H
00002 #define __XPROTOCOL_H
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055 #ifdef __CINT__
00056 #define __attribute__(x)
00057 #endif
00058
00059 #include "XProtocol/XPtypes.hh"
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070 #define kXR_PROTOCOLVERSION 0x00000500
00071 #define kXR_PROTXATTVERSION 0x00000500
00072 #define kXR_PROTTLSVERSION 0x00000500
00073 #define kXR_PROTSIGNVERSION 0x00000310
00074 #define kXR_PROTOCOLVSTRING "5.0.0"
00075
00076
00077
00078
00079
00080
00081
00082 struct ClientInitHandShake {
00083 kXR_int32 first;
00084 kXR_int32 second;
00085 kXR_int32 third;
00086 kXR_int32 fourth;
00087 kXR_int32 fifth;
00088 };
00089
00090
00091
00092 struct ServerInitHandShake {
00093 kXR_int32 msglen;
00094 kXR_int32 protover;
00095 kXR_int32 msgval;
00096 };
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109 enum XRequestTypes {
00110 kXR_1stRequest= 3000,
00111 kXR_auth = 3000,
00112 kXR_query,
00113 kXR_chmod,
00114 kXR_close,
00115 kXR_dirlist,
00116 kXR_gpfile,
00117 kXR_protocol,
00118 kXR_login,
00119 kXR_mkdir,
00120 kXR_mv,
00121 kXR_open,
00122 kXR_ping,
00123 kXR_chkpoint,
00124 kXR_read,
00125 kXR_rm,
00126 kXR_rmdir,
00127 kXR_sync,
00128 kXR_stat,
00129 kXR_set,
00130 kXR_write,
00131 kXR_fattr,
00132 kXR_prepare,
00133 kXR_statx,
00134 kXR_endsess,
00135 kXR_bind,
00136 kXR_readv,
00137 kXR_pgwrite,
00138 kXR_locate,
00139 kXR_truncate,
00140 kXR_sigver,
00141 kXR_pgread,
00142 kXR_writev,
00143 kXR_REQFENCE
00144 };
00145
00146
00147
00148 struct ClientRequestHdr {
00149 kXR_char streamid[2];
00150 kXR_unt16 requestid;
00151 kXR_char body[16];
00152 kXR_int32 dlen;
00153 };
00154
00155
00156
00157
00158
00159 struct ClientAuthRequest {
00160 kXR_char streamid[2];
00161 kXR_unt16 requestid;
00162 kXR_char reserved[12];
00163 kXR_char credtype[4];
00164 kXR_int32 dlen;
00165 };
00166
00167
00168
00169
00170
00171 struct ClientBindRequest {
00172 kXR_char streamid[2];
00173 kXR_unt16 requestid;
00174 kXR_char sessid[16];
00175 kXR_int32 dlen;
00176 };
00177
00178
00179
00180
00181
00182 struct ClientChmodRequest {
00183 kXR_char streamid[2];
00184 kXR_unt16 requestid;
00185 kXR_char reserved[14];
00186 kXR_unt16 mode;
00187 kXR_int32 dlen;
00188 };
00189
00190
00191
00192
00193
00194 struct ClientCloseRequest {
00195 kXR_char streamid[2];
00196 kXR_unt16 requestid;
00197 kXR_char fhandle[4];
00198 kXR_char reserved[12];
00199 kXR_int32 dlen;
00200 };
00201
00202
00203
00204
00205
00206 enum XDirlistRequestOption {
00207 kXR_online = 1,
00208 kXR_dstat = 2
00209 };
00210
00211 struct ClientDirlistRequest {
00212 kXR_char streamid[2];
00213 kXR_unt16 requestid;
00214 kXR_char reserved[15];
00215 kXR_char options[1];
00216 kXR_int32 dlen;
00217 };
00218
00219
00220
00221
00222
00223 struct ClientEndsessRequest {
00224 kXR_char streamid[2];
00225 kXR_unt16 requestid;
00226 kXR_char sessid[16];
00227 kXR_int32 dlen;
00228 };
00229
00230
00231
00232
00233
00234
00235
00236 enum xfaSubCode {
00237 kXR_fattrDel = 0,
00238 kXR_fattrGet = 1,
00239 kXR_fattrList = 2,
00240 kXR_fattrSet = 3,
00241 kXR_fatrrMaxSC = 3
00242 };
00243
00244
00245
00246 enum xfaLimits {
00247 kXR_faMaxVars = 16,
00248 kXR_faMaxNlen = 248,
00249 kXR_faMaxVlen = 65536
00250 };
00251
00252 struct ClientFattrRequest {
00253 kXR_char streamid[2];
00254 kXR_unt16 requestid;
00255 kXR_char fhandle[4];
00256 kXR_char subcode;
00257 kXR_char numattr;
00258 kXR_char options;
00259 kXR_char reserved[9];
00260 kXR_int32 dlen;
00261
00262
00263
00264 static const int isNew = 0x01;
00265 static const int aData = 0x10;
00266
00267
00268
00269 static char* NVecInsert( const char *name, char *buffer );
00270
00271
00272
00273 static char* VVecInsert( const char *value, char *buffer );
00274
00275
00276
00277 static char* NVecRead( char* buffer, kXR_unt16 &rc );
00278
00279
00280
00281 static char* NVecRead( char* buffer, char *&name );
00282
00283
00284
00285 static char* VVecRead( char* buffer, kXR_int32 &len );
00286
00287
00288
00289 static char* VVecRead( char* buffer, kXR_int32 len, char *&value );
00290
00291 };
00292
00293
00294
00295
00296
00297 struct ClientGPfileRequest {
00298 kXR_char streamid[2];
00299 kXR_unt16 requestid;
00300 kXR_int32 options;
00301 kXR_char reserved[8];
00302 kXR_int32 buffsz;
00303 kXR_int32 dlen;
00304 };
00305
00306
00307
00308
00309
00310 struct ClientLocateRequest {
00311 kXR_char streamid[2];
00312 kXR_unt16 requestid;
00313 kXR_unt16 options;
00314 kXR_char reserved[14];
00315 kXR_int32 dlen;
00316 };
00317
00318
00319
00320
00321
00322
00323 enum XLoginAbility {
00324 kXR_nothing = 0,
00325 kXR_fullurl = 1,
00326 kXR_multipr = 3,
00327 kXR_readrdok= 4,
00328 kXR_hasipv64= 8,
00329 kXR_onlyprv4= 16,
00330 kXR_onlyprv6= 32,
00331 kXR_lclfile = 64
00332 };
00333
00334
00335 enum XLoginCapVer {
00336 kXR_lcvnone = 0,
00337 kXR_vermask = 63,
00338 kXR_asyncap = 128
00339 };
00340
00341
00342
00343 enum XLoginVersion {
00344 kXR_ver000 = 0,
00345 kXR_ver001 = 1,
00346 kXR_ver002 = 2,
00347 kXR_ver003 = 3,
00348 kXR_ver004 = 4,
00349 kXR_ver005 = 5
00350 };
00351
00352 struct ClientLoginRequest {
00353 kXR_char streamid[2];
00354 kXR_unt16 requestid;
00355 kXR_int32 pid;
00356 kXR_char username[8];
00357 kXR_char reserved;
00358 kXR_char ability;
00359 kXR_char capver[1];
00360 kXR_char reserved2;
00361 kXR_int32 dlen;
00362 };
00363
00364
00365
00366
00367
00368 enum XMkdirOptions {
00369 kXR_mknone = 0,
00370 kXR_mkdirpath = 1
00371 };
00372
00373 struct ClientMkdirRequest {
00374 kXR_char streamid[2];
00375 kXR_unt16 requestid;
00376 kXR_char options[1];
00377 kXR_char reserved[13];
00378 kXR_unt16 mode;
00379 kXR_int32 dlen;
00380 };
00381
00382
00383
00384
00385
00386 struct ClientMvRequest {
00387 kXR_char streamid[2];
00388 kXR_unt16 requestid;
00389 kXR_char reserved[14];
00390 kXR_int16 arg1len;
00391 kXR_int32 dlen;
00392 };
00393
00394
00395
00396
00397
00398
00399 enum XOpenRequestMode {
00400 kXR_ur = 0x100,
00401 kXR_uw = 0x080,
00402 kXR_ux = 0x040,
00403 kXR_gr = 0x020,
00404 kXR_gw = 0x010,
00405 kXR_gx = 0x008,
00406 kXR_or = 0x004,
00407 kXR_ow = 0x002,
00408 kXR_ox = 0x001
00409 };
00410
00411 enum XOpenRequestOption {
00412 kXR_compress = 1,
00413 kXR_delete = 2,
00414 kXR_force = 4,
00415 kXR_new = 8,
00416 kXR_open_read= 16,
00417 kXR_open_updt= 32,
00418 kXR_async = 64,
00419 kXR_refresh = 128,
00420 kXR_mkpath = 256,
00421 kXR_prefname = 256,
00422 kXR_open_apnd= 512,
00423 kXR_retstat = 1024,
00424 kXR_4dirlist = 1024,
00425 kXR_replica = 2048,
00426 kXR_posc = 4096,
00427 kXR_nowait = 8192,
00428 kXR_seqio =16384,
00429 kXR_open_wrto=32768
00430 };
00431
00432 struct ClientOpenRequest {
00433 kXR_char streamid[2];
00434 kXR_unt16 requestid;
00435 kXR_unt16 mode;
00436 kXR_unt16 options;
00437 kXR_char reserved[12];
00438 kXR_int32 dlen;
00439 };
00440
00441
00442
00443
00444
00445
00446
00447 namespace XrdProto
00448 {
00449 static const int kXR_pgPageSZ = 4096;
00450 static const int kXR_pgUnitSZ = kXR_pgPageSZ + sizeof(kXR_unt32);
00451
00452
00453
00454 static const kXR_char kXR_AnyPath = 0xff;
00455 static const int kXR_pgRetry = 0x01;
00456 }
00457
00458 struct ClientPgReadRequest {
00459 kXR_char streamid[2];
00460 kXR_unt16 requestid;
00461 kXR_char fhandle[4];
00462 kXR_int64 offset;
00463 kXR_int32 rlen;
00464 kXR_int32 dlen;
00465 };
00466
00467 struct ClientPgReadReqArgs {
00468 kXR_char pathid;
00469 kXR_char reqflags;
00470 };
00471
00472 namespace
00473 {
00474 }
00475
00476
00477
00478
00479
00480 struct ClientPgWriteRequest {
00481 kXR_char streamid[2];
00482 kXR_unt16 requestid;
00483 kXR_char fhandle[4];
00484 kXR_int64 offset;
00485 kXR_char pathid;
00486 kXR_char reqflags;
00487 kXR_char reserved[2];
00488 kXR_int32 dlen;
00489
00490 };
00491
00492
00493
00494
00495
00496 struct ClientPingRequest {
00497 kXR_char streamid[2];
00498 kXR_unt16 requestid;
00499 kXR_char reserved[16];
00500 kXR_int32 dlen;
00501 };
00502
00503
00504
00505
00506
00507 struct ClientProtocolRequest {
00508 kXR_char streamid[2];
00509 kXR_unt16 requestid;
00510 kXR_int32 clientpv;
00511 kXR_char flags;
00512 kXR_char expect;
00513 kXR_char reserved[10];
00514 kXR_int32 dlen;
00515
00516 enum RequestFlags {
00517 kXR_secreqs = 0x01,
00518 kXR_ableTLS = 0x02,
00519 kXR_wantTLS = 0x04
00520 };
00521
00522 enum ExpectFlags {
00523 kXR_ExpMask = 0x0f,
00524 kXR_ExpNone = 0x00,
00525 kXR_ExpBind = 0x01,
00526 kXR_ExpGPF = 0x02,
00527 kXR_ExpLogin = 0x03,
00528 kXR_ExpTPC = 0x04,
00529 kXR_ExpGPFA = 0x08
00530 };
00531 };
00532
00533
00534
00535
00536
00537 enum XPrepRequestOption {
00538 kXR_cancel = 1,
00539 kXR_notify = 2,
00540 kXR_noerrs = 4,
00541 kXR_stage = 8,
00542 kXR_wmode = 16,
00543 kXR_coloc = 32,
00544 kXR_fresh = 64,
00545 kXR_usetcp = 128,
00546
00547 kXR_evict = 0x0001
00548 };
00549
00550 struct ClientPrepareRequest {
00551 kXR_char streamid[2];
00552 kXR_unt16 requestid;
00553 kXR_char options;
00554 kXR_char prty;
00555 kXR_unt16 port;
00556 kXR_unt16 optionX;
00557 kXR_char reserved[10];
00558 kXR_int32 dlen;
00559 };
00560
00561
00562
00563
00564
00565 enum XQueryType {
00566 kXR_QStats = 1,
00567 kXR_QPrep = 2,
00568 kXR_Qcksum = 3,
00569 kXR_Qxattr = 4,
00570 kXR_Qspace = 5,
00571 kXR_Qckscan= 6,
00572 kXR_Qconfig= 7,
00573 kXR_Qvisa = 8,
00574 kXR_Qopaque=16,
00575 kXR_Qopaquf=32,
00576 kXR_Qopaqug=64
00577 };
00578
00579 struct ClientQueryRequest {
00580 kXR_char streamid[2];
00581 kXR_unt16 requestid;
00582 kXR_unt16 infotype;
00583 kXR_char reserved1[2];
00584 kXR_char fhandle[4];
00585 kXR_char reserved2[8];
00586 kXR_int32 dlen;
00587 };
00588
00589
00590
00591
00592
00593 struct ClientReadRequest {
00594 kXR_char streamid[2];
00595 kXR_unt16 requestid;
00596 kXR_char fhandle[4];
00597 kXR_int64 offset;
00598 kXR_int32 rlen;
00599 kXR_int32 dlen;
00600
00601 };
00602
00603 struct read_args {
00604 kXR_char pathid;
00605 kXR_char reserved[7];
00606
00607 };
00608
00609 struct readahead_list {
00610 kXR_char fhandle[4];
00611 kXR_int32 rlen;
00612 kXR_int64 offset;
00613 };
00614
00615
00616
00617
00618
00619 struct ClientReadVRequest {
00620 kXR_char streamid[2];
00621 kXR_unt16 requestid;
00622 kXR_char reserved[15];
00623 kXR_char pathid;
00624 kXR_int32 dlen;
00625
00626 };
00627
00628 namespace XrdProto
00629 {
00630 struct read_list {
00631 kXR_char fhandle[4];
00632 kXR_int32 rlen;
00633 kXR_int64 offset;
00634 };
00635 }
00636
00637
00638
00639
00640
00641 struct ClientRmRequest {
00642 kXR_char streamid[2];
00643 kXR_unt16 requestid;
00644 kXR_char reserved[16];
00645 kXR_int32 dlen;
00646 };
00647
00648
00649
00650
00651
00652 struct ClientRmdirRequest {
00653 kXR_char streamid[2];
00654 kXR_unt16 requestid;
00655 kXR_char reserved[16];
00656 kXR_int32 dlen;
00657 };
00658
00659
00660
00661
00662
00663 struct ClientSetRequest {
00664 kXR_char streamid[2];
00665 kXR_unt16 requestid;
00666 kXR_char reserved[15];
00667 kXR_char modifier;
00668 kXR_int32 dlen;
00669 };
00670
00671
00672
00673
00674
00675
00676 enum XSecCrypto {
00677 kXR_SHA256 = 0x01,
00678 kXR_HashMask = 0x0f,
00679 kXR_rsaKey = 0x80
00680 };
00681
00682
00683 enum XSecFlags {
00684 kXR_nodata = 1
00685 };
00686
00687
00688 enum XSecVersion {
00689 kXR_Ver_00 = 0
00690 };
00691
00692 struct ClientSigverRequest {
00693 kXR_char streamid[2];
00694 kXR_unt16 requestid;
00695 kXR_unt16 expectrid;
00696 kXR_char version;
00697 kXR_char flags;
00698 kXR_unt64 seqno;
00699 kXR_char crypto;
00700 kXR_char rsvd2[3];
00701 kXR_int32 dlen;
00702 };
00703
00704
00705
00706
00707
00708 enum XStatRequestOption {
00709 kXR_vfs = 1
00710 };
00711
00712 struct ClientStatRequest {
00713 kXR_char streamid[2];
00714 kXR_unt16 requestid;
00715 kXR_char options;
00716 kXR_char reserved[11];
00717 kXR_char fhandle[4];
00718 kXR_int32 dlen;
00719 };
00720
00721
00722
00723
00724
00725 struct ClientSyncRequest {
00726 kXR_char streamid[2];
00727 kXR_unt16 requestid;
00728 kXR_char fhandle[4];
00729 kXR_char reserved[12];
00730 kXR_int32 dlen;
00731 };
00732
00733
00734
00735
00736
00737 struct ClientTruncateRequest {
00738 kXR_char streamid[2];
00739 kXR_unt16 requestid;
00740 kXR_char fhandle[4];
00741 kXR_int64 offset;
00742 kXR_char reserved[4];
00743 kXR_int32 dlen;
00744 };
00745
00746
00747
00748
00749
00750 struct ClientWriteRequest {
00751 kXR_char streamid[2];
00752 kXR_unt16 requestid;
00753 kXR_char fhandle[4];
00754 kXR_int64 offset;
00755 kXR_char pathid;
00756 kXR_char reserved[3];
00757 kXR_int32 dlen;
00758 };
00759
00760
00761
00762
00763
00764 struct ClientWriteVRequest {
00765 kXR_char streamid[2];
00766 kXR_unt16 requestid;
00767 kXR_char options;
00768 kXR_char reserved[15];
00769 kXR_int32 dlen;
00770
00771
00772 static const kXR_int32 doSync = 0x01;
00773 };
00774
00775 namespace XrdProto
00776 {
00777 struct write_list {
00778 kXR_char fhandle[4];
00779 kXR_int32 wlen;
00780 kXR_int64 offset;
00781 };
00782 }
00783
00784
00785
00786
00787
00788 typedef union {
00789 struct ClientRequestHdr header;
00790 struct ClientAuthRequest auth;
00791 struct ClientBindRequest bind;
00792 struct ClientChmodRequest chmod;
00793 struct ClientCloseRequest close;
00794 struct ClientDirlistRequest dirlist;
00795 struct ClientEndsessRequest endsess;
00796 struct ClientFattrRequest fattr;
00797 struct ClientGPfileRequest gpfile;
00798 struct ClientLocateRequest locate;
00799 struct ClientLoginRequest login;
00800 struct ClientMkdirRequest mkdir;
00801 struct ClientMvRequest mv;
00802 struct ClientOpenRequest open;
00803 struct ClientPgReadRequest pgread;
00804 struct ClientPgWriteRequest pgwrite;
00805 struct ClientPingRequest ping;
00806 struct ClientPrepareRequest prepare;
00807 struct ClientProtocolRequest protocol;
00808 struct ClientQueryRequest query;
00809 struct ClientReadRequest read;
00810 struct ClientReadVRequest readv;
00811 struct ClientRmRequest rm;
00812 struct ClientRmdirRequest rmdir;
00813 struct ClientSetRequest set;
00814 struct ClientSigverRequest sigver;
00815 struct ClientStatRequest stat;
00816 struct ClientSyncRequest sync;
00817 struct ClientTruncateRequest truncate;
00818 struct ClientWriteRequest write;
00819 struct ClientWriteVRequest writev;
00820 } ClientRequest;
00821
00822 typedef union {
00823 struct ClientRequestHdr header;
00824 struct ClientSigverRequest sigver;
00825 } SecurityRequest;
00826
00827
00828
00829
00830
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840 enum XResponseType {
00841 kXR_ok = 0,
00842 kXR_oksofar = 4000,
00843 kXR_attn,
00844 kXR_authmore,
00845 kXR_error,
00846 kXR_redirect,
00847 kXR_wait,
00848 kXR_waitresp,
00849 kXR_status,
00850 kXR_noResponsesYet = 10000
00851 };
00852
00853
00854
00855 struct ServerResponseHeader {
00856 kXR_char streamid[2];
00857 kXR_unt16 status;
00858 kXR_int32 dlen;
00859 };
00860
00861
00862
00863 struct ServerResponseBody_Buffer {
00864 char data[4096];
00865 };
00866
00867
00868
00869
00870
00871 enum XActionCode {
00872 kXR_asyncab = 5000,
00873 kXR_asyncdi,
00874 kXR_asyncms = 5002,
00875 kXR_asyncrd,
00876 kXR_asyncwt,
00877 kXR_asyncav,
00878 kXR_asynunav,
00879 kXR_asyncgo,
00880 kXR_asynresp= 5008
00881 };
00882
00883 struct ServerResponseBody_Attn {
00884 kXR_int32 actnum;
00885 char parms[4096];
00886 };
00887
00888 struct ServerResponseBody_Attn_asyncms {
00889 kXR_int32 actnum;
00890 char reserved[4];
00891 ServerResponseHeader resphdr;
00892 char respdata[4096];
00893 };
00894
00895 struct ServerResponseBody_Attn_asynresp {
00896 kXR_int32 actnum;
00897 char reserved[4];
00898 ServerResponseHeader resphdr;
00899 char respdata[4096];
00900 };
00901
00902
00903
00904
00905
00906 struct ServerResponseBody_Authmore {
00907 char data[4096];
00908 };
00909
00910
00911
00912
00913
00914 struct ServerResponseBody_Bind {
00915 kXR_char substreamid;
00916 };
00917
00918
00919
00920
00921
00922 enum XErrorCode {
00923 kXR_ArgInvalid = 3000,
00924 kXR_ArgMissing,
00925 kXR_ArgTooLong,
00926 kXR_FileLocked,
00927 kXR_FileNotOpen,
00928 kXR_FSError,
00929 kXR_InvalidRequest,
00930 kXR_IOError,
00931 kXR_NoMemory,
00932 kXR_NoSpace,
00933 kXR_NotAuthorized,
00934 kXR_NotFound,
00935 kXR_ServerError,
00936 kXR_Unsupported,
00937 kXR_noserver,
00938 kXR_NotFile,
00939 kXR_isDirectory,
00940 kXR_Cancelled,
00941 kXR_ItExists,
00942 kXR_ChkSumErr,
00943 kXR_inProgress,
00944 kXR_overQuota,
00945 kXR_SigVerErr,
00946 kXR_DecryptErr,
00947 kXR_Overloaded,
00948 kXR_fsReadOnly,
00949 kXR_BadPayload,
00950 kXR_AttrNotFound,
00951 kXR_TLSRequired,
00952 kXR_noReplicas,
00953 kXR_AuthFailed,
00954 kXR_ERRFENCE,
00955 kXR_noErrorYet = 10000
00956 };
00957
00958 struct ServerResponseBody_Error {
00959 kXR_int32 errnum;
00960 char errmsg[4096];
00961 };
00962
00963
00964
00965
00966
00967 struct ServerResponseBody_Login {
00968 kXR_char sessid[16];
00969 kXR_char sec[4096];
00970 };
00971
00972
00973
00974
00975
00976 struct ServerResponseBody_Open {
00977 kXR_char fhandle[4];
00978 kXR_int32 cpsize;
00979 kXR_char cptype[4];
00980 };
00981
00982
00983
00984
00985
00986 struct ServerResponseBody_pgRead {
00987 kXR_int64 offset;
00988
00989 };
00990
00991
00992
00993
00994
00995 struct ServerResponseBody_pgWrite {
00996 kXR_int64 offset;
00997
00998 };
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008 struct ServerResponseSVec_Protocol {
01009 kXR_char reqindx;
01010 kXR_char reqsreq;
01011 };
01012
01013 struct ServerResponseReqs_Protocol {
01014 kXR_char theTag;
01015 kXR_char rsvd;
01016 kXR_char secver;
01017 kXR_char secopt;
01018 kXR_char seclvl;
01019 kXR_char secvsz;
01020 ServerResponseSVec_Protocol secvec;
01021 };
01022
01023
01024
01025 #define kXR_secOData 0x01
01026 #define kXR_secOFrce 0x02
01027
01028
01029
01030 #define kXR_secNone 0
01031 #define kXR_secCompatible 1
01032 #define kXR_secStandard 2
01033 #define kXR_secIntense 3
01034 #define kXR_secPedantic 4
01035
01036
01037
01038 #define kXR_signIgnore 0
01039 #define kXR_signLikely 1
01040 #define kXR_signNeeded 2
01041
01042
01043
01044
01045 #define kXR_secver_0 0
01046
01047
01048
01049 #define kXR_DataServer 1
01050 #define kXR_LBalServer 0
01051
01052
01053
01054
01055 #define kXR_isManager 0x00000002
01056 #define kXR_isServer 0x00000001
01057 #define kXR_attrMeta 0x00000100
01058 #define kXR_attrProxy 0x00000200
01059 #define kXR_attrSuper 0x00000400
01060 #define kXR_attrVirtRdr 0x00000800
01061
01062
01063
01064 #define kXR_anongpf 0x00800000
01065 #define kXR_supgpf 0x00400000
01066 #define kXR_suppgrw 0x00200000
01067 #define kXR_supposc 0x00100000
01068
01069
01070
01071 #define kXR_haveTLS 0x80000000
01072 #define kXR_gotoTLS 0x40000000
01073 #define kXR_tlsAny 0x1f000000
01074 #define kXR_tlsData 0x01000000
01075 #define kXR_tlsGPF 0x02000000
01076 #define kXR_tlsLogin 0x04000000
01077 #define kXR_tlsSess 0x08000000
01078 #define kXR_tlsTPC 0x10000000
01079 #define kXR_tlsGPFA 0x20000000
01080
01081
01082
01083 struct ServerResponseBody_Protocol {
01084 kXR_int32 pval;
01085 kXR_int32 flags;
01086 ServerResponseReqs_Protocol secreq;
01087 };
01088
01089
01090
01091
01092 #define kXR_ShortProtRespLen sizeof(ServerResponseBody_Protocol)-\
01093 sizeof(ServerResponseReqs_Protocol)
01094
01095
01096
01097
01098
01099 struct ServerResponseBody_Redirect {
01100 kXR_int32 port;
01101 char host[4096];
01102 };
01103
01104
01105
01106
01107
01108
01109
01110 enum XStatRespFlags {
01111 kXR_file = 0,
01112 kXR_xset = 1,
01113 kXR_isDir = 2,
01114 kXR_other = 4,
01115 kXR_offline = 8,
01116 kXR_readable=16,
01117 kXR_writable=32,
01118 kXR_poscpend=64,
01119 kXR_bkpexist=128
01120 };
01121
01122
01123
01124
01125
01126 struct ServerResponseBody_Status {
01127 kXR_unt32 crc32c;
01128 kXR_char streamID[2];
01129 kXR_char requestid;
01130 kXR_char resptype;
01131 kXR_char reserved[4];
01132 kXR_int32 dlen;
01133
01134
01135 };
01136
01137 namespace XrdProto
01138 {
01139 enum RespType {
01140
01141 kXR_FinalResult = 0x00,
01142 kXR_PartialResult = 0x01,
01143 kXR_ProgressInfo = 0x02
01144 };
01145
01146
01147
01148 static const int kXR_statusBodyLen = sizeof(ServerResponseBody_Status);
01149 }
01150
01151 struct ServerResponseStatus {
01152 struct ServerResponseHeader hdr;
01153 struct ServerResponseBody_Status bdy;
01154 };
01155
01156
01157
01158
01159
01160 struct ServerResponseBody_Wait {
01161 kXR_int32 seconds;
01162 char infomsg[4096];
01163 };
01164
01165
01166
01167
01168
01169 struct ServerResponseBody_Waitresp {
01170 kXR_int32 seconds;
01171 };
01172
01173
01174
01175
01176
01177 struct ServerResponse
01178 {
01179 ServerResponseHeader hdr;
01180 union
01181 {
01182 ServerResponseBody_Attn attn;
01183 ServerResponseBody_Authmore authmore;
01184 ServerResponseBody_Bind bind;
01185 ServerResponseBody_Buffer buffer;
01186 ServerResponseBody_Error error;
01187 ServerResponseBody_Login login;
01188 ServerResponseBody_pgRead pgread;
01189 ServerResponseBody_pgWrite pgwrite;
01190 ServerResponseBody_Protocol protocol;
01191 ServerResponseBody_Redirect redirect;
01192 ServerResponseBody_Wait wait;
01193 ServerResponseBody_Waitresp waitresp;
01194 } body;
01195 };
01196
01197 struct ALIGN_CHECK {char chkszreq[25-sizeof(ClientRequest)];
01198 char chkszrsp[ 9-sizeof(ServerResponseHeader)];
01199 };
01200
01201
01202
01203
01204
01205 #include <errno.h>
01206 #if defined(WIN32)
01207 #if !defined(ENOTBLK)
01208 # define ENOTBLK 15
01209 #endif
01210 #if !defined(ETXTBSY)
01211 #define ETXTBSY 26
01212 #endif
01213 #if !defined(ENOBUFS)
01214 #define ENOBUFS 105
01215 #endif
01216 #if !defined(ENETUNREACH)
01217 #define ENETUNREACH 114
01218 #endif
01219 #endif
01220
01221 #ifndef ENOATTR
01222 #define ENOATTR ENODATA
01223 #endif
01224
01225 #ifndef EBADRQC
01226 #if defined(__APPLE__)
01227 #define EBADRQC EBADRPC
01228 #endif
01229 #endif
01230
01231 #ifndef EAUTH
01232 #define EAUTH EBADE
01233 #endif
01234
01235 struct stat;
01236
01237 class XProtocol
01238 {
01239 public:
01240
01241
01242
01243 static int mapError(int rc)
01244 {if (rc < 0) rc = -rc;
01245 switch(rc)
01246 {case ENOENT: return kXR_NotFound;
01247 case EINVAL: return kXR_ArgInvalid;
01248 case EPERM: return kXR_NotAuthorized;
01249 case EACCES: return kXR_NotAuthorized;
01250 case EIO: return kXR_IOError;
01251 case ENOMEM: return kXR_NoMemory;
01252 case ENOBUFS: return kXR_NoMemory;
01253 case ENOSPC: return kXR_NoSpace;
01254 case ENAMETOOLONG: return kXR_ArgTooLong;
01255 case ENETUNREACH: return kXR_noserver;
01256 case ENOTBLK: return kXR_NotFile;
01257 case ENOTSUP: return kXR_Unsupported;
01258 case EISDIR: return kXR_isDirectory;
01259 case EEXIST: return kXR_ItExists;
01260 case EBADRQC: return kXR_InvalidRequest;
01261 case ETXTBSY: return kXR_inProgress;
01262 case ENODEV: return kXR_FSError;
01263 case EFAULT: return kXR_ServerError;
01264 case EDOM: return kXR_ChkSumErr;
01265 case EDQUOT: return kXR_overQuota;
01266 case EILSEQ: return kXR_SigVerErr;
01267 case ERANGE: return kXR_DecryptErr;
01268 case EUSERS: return kXR_Overloaded;
01269 case EROFS: return kXR_fsReadOnly;
01270 case ENOATTR: return kXR_AttrNotFound;
01271 case EPROTOTYPE: return kXR_TLSRequired;
01272 case EADDRNOTAVAIL: return kXR_noReplicas;
01273 case EAUTH: return kXR_AuthFailed;
01274 default: return kXR_FSError;
01275 }
01276 }
01277
01278 static int toErrno( int xerr )
01279 {
01280 switch(xerr)
01281 {case kXR_ArgInvalid: return EINVAL;
01282 case kXR_ArgMissing: return EINVAL;
01283 case kXR_ArgTooLong: return ENAMETOOLONG;
01284 case kXR_FileLocked: return EDEADLK;
01285 case kXR_FileNotOpen: return EBADF;
01286 case kXR_FSError: return ENODEV;
01287 case kXR_InvalidRequest:return EBADRQC;
01288 case kXR_IOError: return EIO;
01289 case kXR_NoMemory: return ENOMEM;
01290 case kXR_NoSpace: return ENOSPC;
01291 case kXR_NotAuthorized: return EACCES;
01292 case kXR_NotFound: return ENOENT;
01293 case kXR_ServerError: return EFAULT;
01294 case kXR_Unsupported: return ENOTSUP;
01295 case kXR_noserver: return EHOSTUNREACH;
01296 case kXR_NotFile: return ENOTBLK;
01297 case kXR_isDirectory: return EISDIR;
01298 case kXR_Cancelled: return ECANCELED;
01299 case kXR_ItExists: return EEXIST;
01300 case kXR_ChkSumErr: return EDOM;
01301 case kXR_inProgress: return EINPROGRESS;
01302 case kXR_overQuota: return EDQUOT;
01303 case kXR_SigVerErr: return EILSEQ;
01304 case kXR_DecryptErr: return ERANGE;
01305 case kXR_Overloaded: return EUSERS;
01306 case kXR_fsReadOnly: return EROFS;
01307 case kXR_BadPayload: return EINVAL;
01308 case kXR_AttrNotFound: return ENOATTR;
01309 case kXR_TLSRequired: return EPROTOTYPE;
01310 case kXR_noReplicas: return EADDRNOTAVAIL;
01311 case kXR_AuthFailed: return EAUTH;
01312 default: return ENOMSG;
01313 }
01314 }
01315
01316 static const char *errName(kXR_int32 errCode);
01317
01318 static const char *reqName(kXR_unt16 reqCode);
01319
01320
01321
01322
01323
01324 struct ServerResponseBody_Attn_asyncdi {
01325 kXR_int32 actnum;
01326 kXR_int32 wsec;
01327 kXR_int32 msec;
01328 };
01329
01330 struct ServerResponseBody_Attn_asyncrd {
01331 kXR_int32 actnum;
01332 kXR_int32 port;
01333 char host[4092];
01334 };
01335
01336 struct ServerResponseBody_Attn_asyncwt {
01337 kXR_int32 actnum;
01338 kXR_int32 wsec;
01339 };
01340
01341
01342
01343 enum XReqErrorType {
01344 kGENERICERR = 0,
01345 kREAD,
01346 kWRITE,
01347 kREDIRCONNECT,
01348 kOK,
01349 kNOMORESTREAMS
01350
01351 };
01352
01353 typedef kXR_int32 ServerResponseType;
01354
01355 #define kXR_maxReqRetry 10
01356
01357 };
01358 #endif