1// Code generated by protoc-gen-gogo. 2// source: auth.proto 3// DO NOT EDIT! 4 5/* 6 Package authpb is a generated protocol buffer package. 7 8 It is generated from these files: 9 auth.proto 10 11 It has these top-level messages: 12 User 13 Permission 14 Role 15*/ 16package authpb 17 18import ( 19 "fmt" 20 21 proto "github.com/golang/protobuf/proto" 22 23 math "math" 24 25 io "io" 26) 27 28// Reference imports to suppress errors if they are not otherwise used. 29var _ = proto.Marshal 30var _ = fmt.Errorf 31var _ = math.Inf 32 33// This is a compile-time assertion to ensure that this generated file 34// is compatible with the proto package it is being compiled against. 35// A compilation error at this line likely means your copy of the 36// proto package needs to be updated. 37const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package 38 39type Permission_Type int32 40 41const ( 42 READ Permission_Type = 0 43 WRITE Permission_Type = 1 44 READWRITE Permission_Type = 2 45) 46 47var Permission_Type_name = map[int32]string{ 48 0: "READ", 49 1: "WRITE", 50 2: "READWRITE", 51} 52var Permission_Type_value = map[string]int32{ 53 "READ": 0, 54 "WRITE": 1, 55 "READWRITE": 2, 56} 57 58func (x Permission_Type) String() string { 59 return proto.EnumName(Permission_Type_name, int32(x)) 60} 61func (Permission_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptorAuth, []int{1, 0} } 62 63// User is a single entry in the bucket authUsers 64type User struct { 65 Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` 66 Password []byte `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"` 67 Roles []string `protobuf:"bytes,3,rep,name=roles" json:"roles,omitempty"` 68} 69 70func (m *User) Reset() { *m = User{} } 71func (m *User) String() string { return proto.CompactTextString(m) } 72func (*User) ProtoMessage() {} 73func (*User) Descriptor() ([]byte, []int) { return fileDescriptorAuth, []int{0} } 74 75// Permission is a single entity 76type Permission struct { 77 PermType Permission_Type `protobuf:"varint,1,opt,name=permType,proto3,enum=authpb.Permission_Type" json:"permType,omitempty"` 78 Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` 79 RangeEnd []byte `protobuf:"bytes,3,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"` 80} 81 82func (m *Permission) Reset() { *m = Permission{} } 83func (m *Permission) String() string { return proto.CompactTextString(m) } 84func (*Permission) ProtoMessage() {} 85func (*Permission) Descriptor() ([]byte, []int) { return fileDescriptorAuth, []int{1} } 86 87// Role is a single entry in the bucket authRoles 88type Role struct { 89 Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` 90 KeyPermission []*Permission `protobuf:"bytes,2,rep,name=keyPermission" json:"keyPermission,omitempty"` 91} 92 93func (m *Role) Reset() { *m = Role{} } 94func (m *Role) String() string { return proto.CompactTextString(m) } 95func (*Role) ProtoMessage() {} 96func (*Role) Descriptor() ([]byte, []int) { return fileDescriptorAuth, []int{2} } 97 98func init() { 99 proto.RegisterType((*User)(nil), "authpb.User") 100 proto.RegisterType((*Permission)(nil), "authpb.Permission") 101 proto.RegisterType((*Role)(nil), "authpb.Role") 102 proto.RegisterEnum("authpb.Permission_Type", Permission_Type_name, Permission_Type_value) 103} 104func (m *User) Marshal() (dAtA []byte, err error) { 105 size := m.Size() 106 dAtA = make([]byte, size) 107 n, err := m.MarshalTo(dAtA) 108 if err != nil { 109 return nil, err 110 } 111 return dAtA[:n], nil 112} 113 114func (m *User) MarshalTo(dAtA []byte) (int, error) { 115 var i int 116 _ = i 117 var l int 118 _ = l 119 if len(m.Name) > 0 { 120 dAtA[i] = 0xa 121 i++ 122 i = encodeVarintAuth(dAtA, i, uint64(len(m.Name))) 123 i += copy(dAtA[i:], m.Name) 124 } 125 if len(m.Password) > 0 { 126 dAtA[i] = 0x12 127 i++ 128 i = encodeVarintAuth(dAtA, i, uint64(len(m.Password))) 129 i += copy(dAtA[i:], m.Password) 130 } 131 if len(m.Roles) > 0 { 132 for _, s := range m.Roles { 133 dAtA[i] = 0x1a 134 i++ 135 l = len(s) 136 for l >= 1<<7 { 137 dAtA[i] = uint8(uint64(l)&0x7f | 0x80) 138 l >>= 7 139 i++ 140 } 141 dAtA[i] = uint8(l) 142 i++ 143 i += copy(dAtA[i:], s) 144 } 145 } 146 return i, nil 147} 148 149func (m *Permission) Marshal() (dAtA []byte, err error) { 150 size := m.Size() 151 dAtA = make([]byte, size) 152 n, err := m.MarshalTo(dAtA) 153 if err != nil { 154 return nil, err 155 } 156 return dAtA[:n], nil 157} 158 159func (m *Permission) MarshalTo(dAtA []byte) (int, error) { 160 var i int 161 _ = i 162 var l int 163 _ = l 164 if m.PermType != 0 { 165 dAtA[i] = 0x8 166 i++ 167 i = encodeVarintAuth(dAtA, i, uint64(m.PermType)) 168 } 169 if len(m.Key) > 0 { 170 dAtA[i] = 0x12 171 i++ 172 i = encodeVarintAuth(dAtA, i, uint64(len(m.Key))) 173 i += copy(dAtA[i:], m.Key) 174 } 175 if len(m.RangeEnd) > 0 { 176 dAtA[i] = 0x1a 177 i++ 178 i = encodeVarintAuth(dAtA, i, uint64(len(m.RangeEnd))) 179 i += copy(dAtA[i:], m.RangeEnd) 180 } 181 return i, nil 182} 183 184func (m *Role) Marshal() (dAtA []byte, err error) { 185 size := m.Size() 186 dAtA = make([]byte, size) 187 n, err := m.MarshalTo(dAtA) 188 if err != nil { 189 return nil, err 190 } 191 return dAtA[:n], nil 192} 193 194func (m *Role) MarshalTo(dAtA []byte) (int, error) { 195 var i int 196 _ = i 197 var l int 198 _ = l 199 if len(m.Name) > 0 { 200 dAtA[i] = 0xa 201 i++ 202 i = encodeVarintAuth(dAtA, i, uint64(len(m.Name))) 203 i += copy(dAtA[i:], m.Name) 204 } 205 if len(m.KeyPermission) > 0 { 206 for _, msg := range m.KeyPermission { 207 dAtA[i] = 0x12 208 i++ 209 i = encodeVarintAuth(dAtA, i, uint64(msg.Size())) 210 n, err := msg.MarshalTo(dAtA[i:]) 211 if err != nil { 212 return 0, err 213 } 214 i += n 215 } 216 } 217 return i, nil 218} 219 220func encodeFixed64Auth(dAtA []byte, offset int, v uint64) int { 221 dAtA[offset] = uint8(v) 222 dAtA[offset+1] = uint8(v >> 8) 223 dAtA[offset+2] = uint8(v >> 16) 224 dAtA[offset+3] = uint8(v >> 24) 225 dAtA[offset+4] = uint8(v >> 32) 226 dAtA[offset+5] = uint8(v >> 40) 227 dAtA[offset+6] = uint8(v >> 48) 228 dAtA[offset+7] = uint8(v >> 56) 229 return offset + 8 230} 231func encodeFixed32Auth(dAtA []byte, offset int, v uint32) int { 232 dAtA[offset] = uint8(v) 233 dAtA[offset+1] = uint8(v >> 8) 234 dAtA[offset+2] = uint8(v >> 16) 235 dAtA[offset+3] = uint8(v >> 24) 236 return offset + 4 237} 238func encodeVarintAuth(dAtA []byte, offset int, v uint64) int { 239 for v >= 1<<7 { 240 dAtA[offset] = uint8(v&0x7f | 0x80) 241 v >>= 7 242 offset++ 243 } 244 dAtA[offset] = uint8(v) 245 return offset + 1 246} 247func (m *User) Size() (n int) { 248 var l int 249 _ = l 250 l = len(m.Name) 251 if l > 0 { 252 n += 1 + l + sovAuth(uint64(l)) 253 } 254 l = len(m.Password) 255 if l > 0 { 256 n += 1 + l + sovAuth(uint64(l)) 257 } 258 if len(m.Roles) > 0 { 259 for _, s := range m.Roles { 260 l = len(s) 261 n += 1 + l + sovAuth(uint64(l)) 262 } 263 } 264 return n 265} 266 267func (m *Permission) Size() (n int) { 268 var l int 269 _ = l 270 if m.PermType != 0 { 271 n += 1 + sovAuth(uint64(m.PermType)) 272 } 273 l = len(m.Key) 274 if l > 0 { 275 n += 1 + l + sovAuth(uint64(l)) 276 } 277 l = len(m.RangeEnd) 278 if l > 0 { 279 n += 1 + l + sovAuth(uint64(l)) 280 } 281 return n 282} 283 284func (m *Role) Size() (n int) { 285 var l int 286 _ = l 287 l = len(m.Name) 288 if l > 0 { 289 n += 1 + l + sovAuth(uint64(l)) 290 } 291 if len(m.KeyPermission) > 0 { 292 for _, e := range m.KeyPermission { 293 l = e.Size() 294 n += 1 + l + sovAuth(uint64(l)) 295 } 296 } 297 return n 298} 299 300func sovAuth(x uint64) (n int) { 301 for { 302 n++ 303 x >>= 7 304 if x == 0 { 305 break 306 } 307 } 308 return n 309} 310func sozAuth(x uint64) (n int) { 311 return sovAuth(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 312} 313func (m *User) Unmarshal(dAtA []byte) error { 314 l := len(dAtA) 315 iNdEx := 0 316 for iNdEx < l { 317 preIndex := iNdEx 318 var wire uint64 319 for shift := uint(0); ; shift += 7 { 320 if shift >= 64 { 321 return ErrIntOverflowAuth 322 } 323 if iNdEx >= l { 324 return io.ErrUnexpectedEOF 325 } 326 b := dAtA[iNdEx] 327 iNdEx++ 328 wire |= (uint64(b) & 0x7F) << shift 329 if b < 0x80 { 330 break 331 } 332 } 333 fieldNum := int32(wire >> 3) 334 wireType := int(wire & 0x7) 335 if wireType == 4 { 336 return fmt.Errorf("proto: User: wiretype end group for non-group") 337 } 338 if fieldNum <= 0 { 339 return fmt.Errorf("proto: User: illegal tag %d (wire type %d)", fieldNum, wire) 340 } 341 switch fieldNum { 342 case 1: 343 if wireType != 2 { 344 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 345 } 346 var byteLen int 347 for shift := uint(0); ; shift += 7 { 348 if shift >= 64 { 349 return ErrIntOverflowAuth 350 } 351 if iNdEx >= l { 352 return io.ErrUnexpectedEOF 353 } 354 b := dAtA[iNdEx] 355 iNdEx++ 356 byteLen |= (int(b) & 0x7F) << shift 357 if b < 0x80 { 358 break 359 } 360 } 361 if byteLen < 0 { 362 return ErrInvalidLengthAuth 363 } 364 postIndex := iNdEx + byteLen 365 if postIndex > l { 366 return io.ErrUnexpectedEOF 367 } 368 m.Name = append(m.Name[:0], dAtA[iNdEx:postIndex]...) 369 if m.Name == nil { 370 m.Name = []byte{} 371 } 372 iNdEx = postIndex 373 case 2: 374 if wireType != 2 { 375 return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType) 376 } 377 var byteLen int 378 for shift := uint(0); ; shift += 7 { 379 if shift >= 64 { 380 return ErrIntOverflowAuth 381 } 382 if iNdEx >= l { 383 return io.ErrUnexpectedEOF 384 } 385 b := dAtA[iNdEx] 386 iNdEx++ 387 byteLen |= (int(b) & 0x7F) << shift 388 if b < 0x80 { 389 break 390 } 391 } 392 if byteLen < 0 { 393 return ErrInvalidLengthAuth 394 } 395 postIndex := iNdEx + byteLen 396 if postIndex > l { 397 return io.ErrUnexpectedEOF 398 } 399 m.Password = append(m.Password[:0], dAtA[iNdEx:postIndex]...) 400 if m.Password == nil { 401 m.Password = []byte{} 402 } 403 iNdEx = postIndex 404 case 3: 405 if wireType != 2 { 406 return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType) 407 } 408 var stringLen uint64 409 for shift := uint(0); ; shift += 7 { 410 if shift >= 64 { 411 return ErrIntOverflowAuth 412 } 413 if iNdEx >= l { 414 return io.ErrUnexpectedEOF 415 } 416 b := dAtA[iNdEx] 417 iNdEx++ 418 stringLen |= (uint64(b) & 0x7F) << shift 419 if b < 0x80 { 420 break 421 } 422 } 423 intStringLen := int(stringLen) 424 if intStringLen < 0 { 425 return ErrInvalidLengthAuth 426 } 427 postIndex := iNdEx + intStringLen 428 if postIndex > l { 429 return io.ErrUnexpectedEOF 430 } 431 m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex])) 432 iNdEx = postIndex 433 default: 434 iNdEx = preIndex 435 skippy, err := skipAuth(dAtA[iNdEx:]) 436 if err != nil { 437 return err 438 } 439 if skippy < 0 { 440 return ErrInvalidLengthAuth 441 } 442 if (iNdEx + skippy) > l { 443 return io.ErrUnexpectedEOF 444 } 445 iNdEx += skippy 446 } 447 } 448 449 if iNdEx > l { 450 return io.ErrUnexpectedEOF 451 } 452 return nil 453} 454func (m *Permission) Unmarshal(dAtA []byte) error { 455 l := len(dAtA) 456 iNdEx := 0 457 for iNdEx < l { 458 preIndex := iNdEx 459 var wire uint64 460 for shift := uint(0); ; shift += 7 { 461 if shift >= 64 { 462 return ErrIntOverflowAuth 463 } 464 if iNdEx >= l { 465 return io.ErrUnexpectedEOF 466 } 467 b := dAtA[iNdEx] 468 iNdEx++ 469 wire |= (uint64(b) & 0x7F) << shift 470 if b < 0x80 { 471 break 472 } 473 } 474 fieldNum := int32(wire >> 3) 475 wireType := int(wire & 0x7) 476 if wireType == 4 { 477 return fmt.Errorf("proto: Permission: wiretype end group for non-group") 478 } 479 if fieldNum <= 0 { 480 return fmt.Errorf("proto: Permission: illegal tag %d (wire type %d)", fieldNum, wire) 481 } 482 switch fieldNum { 483 case 1: 484 if wireType != 0 { 485 return fmt.Errorf("proto: wrong wireType = %d for field PermType", wireType) 486 } 487 m.PermType = 0 488 for shift := uint(0); ; shift += 7 { 489 if shift >= 64 { 490 return ErrIntOverflowAuth 491 } 492 if iNdEx >= l { 493 return io.ErrUnexpectedEOF 494 } 495 b := dAtA[iNdEx] 496 iNdEx++ 497 m.PermType |= (Permission_Type(b) & 0x7F) << shift 498 if b < 0x80 { 499 break 500 } 501 } 502 case 2: 503 if wireType != 2 { 504 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) 505 } 506 var byteLen int 507 for shift := uint(0); ; shift += 7 { 508 if shift >= 64 { 509 return ErrIntOverflowAuth 510 } 511 if iNdEx >= l { 512 return io.ErrUnexpectedEOF 513 } 514 b := dAtA[iNdEx] 515 iNdEx++ 516 byteLen |= (int(b) & 0x7F) << shift 517 if b < 0x80 { 518 break 519 } 520 } 521 if byteLen < 0 { 522 return ErrInvalidLengthAuth 523 } 524 postIndex := iNdEx + byteLen 525 if postIndex > l { 526 return io.ErrUnexpectedEOF 527 } 528 m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) 529 if m.Key == nil { 530 m.Key = []byte{} 531 } 532 iNdEx = postIndex 533 case 3: 534 if wireType != 2 { 535 return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType) 536 } 537 var byteLen int 538 for shift := uint(0); ; shift += 7 { 539 if shift >= 64 { 540 return ErrIntOverflowAuth 541 } 542 if iNdEx >= l { 543 return io.ErrUnexpectedEOF 544 } 545 b := dAtA[iNdEx] 546 iNdEx++ 547 byteLen |= (int(b) & 0x7F) << shift 548 if b < 0x80 { 549 break 550 } 551 } 552 if byteLen < 0 { 553 return ErrInvalidLengthAuth 554 } 555 postIndex := iNdEx + byteLen 556 if postIndex > l { 557 return io.ErrUnexpectedEOF 558 } 559 m.RangeEnd = append(m.RangeEnd[:0], dAtA[iNdEx:postIndex]...) 560 if m.RangeEnd == nil { 561 m.RangeEnd = []byte{} 562 } 563 iNdEx = postIndex 564 default: 565 iNdEx = preIndex 566 skippy, err := skipAuth(dAtA[iNdEx:]) 567 if err != nil { 568 return err 569 } 570 if skippy < 0 { 571 return ErrInvalidLengthAuth 572 } 573 if (iNdEx + skippy) > l { 574 return io.ErrUnexpectedEOF 575 } 576 iNdEx += skippy 577 } 578 } 579 580 if iNdEx > l { 581 return io.ErrUnexpectedEOF 582 } 583 return nil 584} 585func (m *Role) Unmarshal(dAtA []byte) error { 586 l := len(dAtA) 587 iNdEx := 0 588 for iNdEx < l { 589 preIndex := iNdEx 590 var wire uint64 591 for shift := uint(0); ; shift += 7 { 592 if shift >= 64 { 593 return ErrIntOverflowAuth 594 } 595 if iNdEx >= l { 596 return io.ErrUnexpectedEOF 597 } 598 b := dAtA[iNdEx] 599 iNdEx++ 600 wire |= (uint64(b) & 0x7F) << shift 601 if b < 0x80 { 602 break 603 } 604 } 605 fieldNum := int32(wire >> 3) 606 wireType := int(wire & 0x7) 607 if wireType == 4 { 608 return fmt.Errorf("proto: Role: wiretype end group for non-group") 609 } 610 if fieldNum <= 0 { 611 return fmt.Errorf("proto: Role: illegal tag %d (wire type %d)", fieldNum, wire) 612 } 613 switch fieldNum { 614 case 1: 615 if wireType != 2 { 616 return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) 617 } 618 var byteLen int 619 for shift := uint(0); ; shift += 7 { 620 if shift >= 64 { 621 return ErrIntOverflowAuth 622 } 623 if iNdEx >= l { 624 return io.ErrUnexpectedEOF 625 } 626 b := dAtA[iNdEx] 627 iNdEx++ 628 byteLen |= (int(b) & 0x7F) << shift 629 if b < 0x80 { 630 break 631 } 632 } 633 if byteLen < 0 { 634 return ErrInvalidLengthAuth 635 } 636 postIndex := iNdEx + byteLen 637 if postIndex > l { 638 return io.ErrUnexpectedEOF 639 } 640 m.Name = append(m.Name[:0], dAtA[iNdEx:postIndex]...) 641 if m.Name == nil { 642 m.Name = []byte{} 643 } 644 iNdEx = postIndex 645 case 2: 646 if wireType != 2 { 647 return fmt.Errorf("proto: wrong wireType = %d for field KeyPermission", wireType) 648 } 649 var msglen int 650 for shift := uint(0); ; shift += 7 { 651 if shift >= 64 { 652 return ErrIntOverflowAuth 653 } 654 if iNdEx >= l { 655 return io.ErrUnexpectedEOF 656 } 657 b := dAtA[iNdEx] 658 iNdEx++ 659 msglen |= (int(b) & 0x7F) << shift 660 if b < 0x80 { 661 break 662 } 663 } 664 if msglen < 0 { 665 return ErrInvalidLengthAuth 666 } 667 postIndex := iNdEx + msglen 668 if postIndex > l { 669 return io.ErrUnexpectedEOF 670 } 671 m.KeyPermission = append(m.KeyPermission, &Permission{}) 672 if err := m.KeyPermission[len(m.KeyPermission)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 673 return err 674 } 675 iNdEx = postIndex 676 default: 677 iNdEx = preIndex 678 skippy, err := skipAuth(dAtA[iNdEx:]) 679 if err != nil { 680 return err 681 } 682 if skippy < 0 { 683 return ErrInvalidLengthAuth 684 } 685 if (iNdEx + skippy) > l { 686 return io.ErrUnexpectedEOF 687 } 688 iNdEx += skippy 689 } 690 } 691 692 if iNdEx > l { 693 return io.ErrUnexpectedEOF 694 } 695 return nil 696} 697func skipAuth(dAtA []byte) (n int, err error) { 698 l := len(dAtA) 699 iNdEx := 0 700 for iNdEx < l { 701 var wire uint64 702 for shift := uint(0); ; shift += 7 { 703 if shift >= 64 { 704 return 0, ErrIntOverflowAuth 705 } 706 if iNdEx >= l { 707 return 0, io.ErrUnexpectedEOF 708 } 709 b := dAtA[iNdEx] 710 iNdEx++ 711 wire |= (uint64(b) & 0x7F) << shift 712 if b < 0x80 { 713 break 714 } 715 } 716 wireType := int(wire & 0x7) 717 switch wireType { 718 case 0: 719 for shift := uint(0); ; shift += 7 { 720 if shift >= 64 { 721 return 0, ErrIntOverflowAuth 722 } 723 if iNdEx >= l { 724 return 0, io.ErrUnexpectedEOF 725 } 726 iNdEx++ 727 if dAtA[iNdEx-1] < 0x80 { 728 break 729 } 730 } 731 return iNdEx, nil 732 case 1: 733 iNdEx += 8 734 return iNdEx, nil 735 case 2: 736 var length int 737 for shift := uint(0); ; shift += 7 { 738 if shift >= 64 { 739 return 0, ErrIntOverflowAuth 740 } 741 if iNdEx >= l { 742 return 0, io.ErrUnexpectedEOF 743 } 744 b := dAtA[iNdEx] 745 iNdEx++ 746 length |= (int(b) & 0x7F) << shift 747 if b < 0x80 { 748 break 749 } 750 } 751 iNdEx += length 752 if length < 0 { 753 return 0, ErrInvalidLengthAuth 754 } 755 return iNdEx, nil 756 case 3: 757 for { 758 var innerWire uint64 759 var start int = iNdEx 760 for shift := uint(0); ; shift += 7 { 761 if shift >= 64 { 762 return 0, ErrIntOverflowAuth 763 } 764 if iNdEx >= l { 765 return 0, io.ErrUnexpectedEOF 766 } 767 b := dAtA[iNdEx] 768 iNdEx++ 769 innerWire |= (uint64(b) & 0x7F) << shift 770 if b < 0x80 { 771 break 772 } 773 } 774 innerWireType := int(innerWire & 0x7) 775 if innerWireType == 4 { 776 break 777 } 778 next, err := skipAuth(dAtA[start:]) 779 if err != nil { 780 return 0, err 781 } 782 iNdEx = start + next 783 } 784 return iNdEx, nil 785 case 4: 786 return iNdEx, nil 787 case 5: 788 iNdEx += 4 789 return iNdEx, nil 790 default: 791 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 792 } 793 } 794 panic("unreachable") 795} 796 797var ( 798 ErrInvalidLengthAuth = fmt.Errorf("proto: negative length found during unmarshaling") 799 ErrIntOverflowAuth = fmt.Errorf("proto: integer overflow") 800) 801 802func init() { proto.RegisterFile("auth.proto", fileDescriptorAuth) } 803 804var fileDescriptorAuth = []byte{ 805 // 288 bytes of a gzipped FileDescriptorProto 806 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x90, 0xc1, 0x4a, 0xc3, 0x30, 807 0x1c, 0xc6, 0x9b, 0xb6, 0x1b, 0xed, 0x5f, 0x27, 0x25, 0x0c, 0x0c, 0x13, 0x42, 0xe9, 0xa9, 0x78, 808 0xa8, 0xb0, 0x5d, 0xbc, 0x2a, 0xf6, 0x20, 0x78, 0x90, 0x50, 0xf1, 0x28, 0x1d, 0x0d, 0x75, 0x6c, 809 0x6d, 0x4a, 0x32, 0x91, 0xbe, 0x89, 0x07, 0x1f, 0x68, 0xc7, 0x3d, 0x82, 0xab, 0x2f, 0x22, 0x4d, 810 0x64, 0x43, 0xdc, 0xed, 0xfb, 0xbe, 0xff, 0x97, 0xe4, 0x97, 0x3f, 0x40, 0xfe, 0xb6, 0x7e, 0x4d, 811 0x1a, 0x29, 0xd6, 0x02, 0x0f, 0x7b, 0xdd, 0xcc, 0x27, 0xe3, 0x52, 0x94, 0x42, 0x47, 0x57, 0xbd, 812 0x32, 0xd3, 0xe8, 0x01, 0xdc, 0x27, 0xc5, 0x25, 0xc6, 0xe0, 0xd6, 0x79, 0xc5, 0x09, 0x0a, 0x51, 813 0x7c, 0xca, 0xb4, 0xc6, 0x13, 0xf0, 0x9a, 0x5c, 0xa9, 0x77, 0x21, 0x0b, 0x62, 0xeb, 0x7c, 0xef, 814 0xf1, 0x18, 0x06, 0x52, 0xac, 0xb8, 0x22, 0x4e, 0xe8, 0xc4, 0x3e, 0x33, 0x26, 0xfa, 0x44, 0x00, 815 0x8f, 0x5c, 0x56, 0x0b, 0xa5, 0x16, 0xa2, 0xc6, 0x33, 0xf0, 0x1a, 0x2e, 0xab, 0xac, 0x6d, 0xcc, 816 0xc5, 0x67, 0xd3, 0xf3, 0xc4, 0xd0, 0x24, 0x87, 0x56, 0xd2, 0x8f, 0xd9, 0xbe, 0x88, 0x03, 0x70, 817 0x96, 0xbc, 0xfd, 0x7d, 0xb0, 0x97, 0xf8, 0x02, 0x7c, 0x99, 0xd7, 0x25, 0x7f, 0xe1, 0x75, 0x41, 818 0x1c, 0x03, 0xa2, 0x83, 0xb4, 0x2e, 0xa2, 0x4b, 0x70, 0xf5, 0x31, 0x0f, 0x5c, 0x96, 0xde, 0xdc, 819 0x05, 0x16, 0xf6, 0x61, 0xf0, 0xcc, 0xee, 0xb3, 0x34, 0x40, 0x78, 0x04, 0x7e, 0x1f, 0x1a, 0x6b, 820 0x47, 0x19, 0xb8, 0x4c, 0xac, 0xf8, 0xd1, 0xcf, 0x5e, 0xc3, 0x68, 0xc9, 0xdb, 0x03, 0x16, 0xb1, 821 0x43, 0x27, 0x3e, 0x99, 0xe2, 0xff, 0xc0, 0xec, 0x6f, 0xf1, 0x96, 0x6c, 0x76, 0xd4, 0xda, 0xee, 822 0xa8, 0xb5, 0xe9, 0x28, 0xda, 0x76, 0x14, 0x7d, 0x75, 0x14, 0x7d, 0x7c, 0x53, 0x6b, 0x3e, 0xd4, 823 0x3b, 0x9e, 0xfd, 0x04, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x76, 0x8d, 0x4f, 0x8f, 0x01, 0x00, 0x00, 824} 825