event_rpcgen.py (54938B)
1 #!/usr/bin/env python 2 # 3 # Copyright (c) 2005-2007 Niels Provos <provos@citi.umich.edu> 4 # Copyright (c) 2007-2012 Niels Provos and Nick Mathewson 5 # All rights reserved. 6 # 7 # Generates marshaling code based on libevent. 8 9 # pylint: disable=too-many-lines 10 # pylint: disable=too-many-branches 11 # pylint: disable=too-many-public-methods 12 # pylint: disable=too-many-statements 13 # pylint: disable=global-statement 14 15 # TODO: 16 # 1) propagate the arguments/options parsed by argparse down to the 17 # instantiated factory objects. 18 # 2) move the globals into a class that manages execution, including the 19 # progress outputs that go to stderr at the moment. 20 # 3) emit other languages. 21 22 import argparse 23 import re 24 import sys 25 26 _NAME = "event_rpcgen.py" 27 _VERSION = "0.1" 28 29 # Globals 30 LINE_COUNT = 0 31 32 CPPCOMMENT_RE = re.compile(r"\/\/.*$") 33 NONIDENT_RE = re.compile(r"\W") 34 PREPROCESSOR_DEF_RE = re.compile(r"^#define") 35 STRUCT_REF_RE = re.compile(r"^struct\[(?P<name>[a-zA-Z_][a-zA-Z0-9_]*)\]$") 36 STRUCT_DEF_RE = re.compile(r"^struct +[a-zA-Z_][a-zA-Z0-9_]* *{$") 37 WHITESPACE_RE = re.compile(r"\s+") 38 39 HEADER_DIRECT = [] 40 CPP_DIRECT = [] 41 42 QUIETLY = False 43 44 45 def declare(s): 46 if not QUIETLY: 47 print(s) 48 49 50 def TranslateList(mylist, mydict): 51 return [x % mydict for x in mylist] 52 53 54 class RpcGenError(Exception): 55 """An Exception class for parse errors.""" 56 57 def __init__(self, why): # pylint: disable=super-init-not-called 58 self.why = why 59 60 def __str__(self): 61 return str(self.why) 62 63 64 # Holds everything that makes a struct 65 class Struct(object): 66 def __init__(self, name): 67 self._name = name 68 self._entries = [] 69 self._tags = {} 70 declare(" Created struct: %s" % name) 71 72 def AddEntry(self, entry): 73 if entry.Tag() in self._tags: 74 raise RpcGenError( 75 'Entry "%s" duplicates tag number %d from "%s" ' 76 "around line %d" 77 % (entry.Name(), entry.Tag(), self._tags[entry.Tag()], LINE_COUNT) 78 ) 79 self._entries.append(entry) 80 self._tags[entry.Tag()] = entry.Name() 81 declare(" Added entry: %s" % entry.Name()) 82 83 def Name(self): 84 return self._name 85 86 def EntryTagName(self, entry): 87 """Creates the name inside an enumeration for distinguishing data 88 types.""" 89 name = "%s_%s" % (self._name, entry.Name()) 90 return name.upper() 91 92 @staticmethod 93 def PrintIndented(filep, ident, code): 94 """Takes an array, add indentation to each entry and prints it.""" 95 for entry in code: 96 filep.write("%s%s\n" % (ident, entry)) 97 98 99 class StructCCode(Struct): 100 """ Knows how to generate C code for a struct """ 101 102 def __init__(self, name): 103 Struct.__init__(self, name) 104 105 def PrintTags(self, filep): 106 """Prints the tag definitions for a structure.""" 107 filep.write("/* Tag definition for %s */\n" % self._name) 108 filep.write("enum %s_ {\n" % self._name.lower()) 109 for entry in self._entries: 110 filep.write(" %s=%d,\n" % (self.EntryTagName(entry), entry.Tag())) 111 filep.write(" %s_MAX_TAGS\n" % (self._name.upper())) 112 filep.write("};\n\n") 113 114 def PrintForwardDeclaration(self, filep): 115 filep.write("struct %s;\n" % self._name) 116 117 def PrintDeclaration(self, filep): 118 filep.write("/* Structure declaration for %s */\n" % self._name) 119 filep.write("struct %s_access_ {\n" % self._name) 120 for entry in self._entries: 121 dcl = entry.AssignDeclaration("(*%s_assign)" % entry.Name()) 122 dcl.extend(entry.GetDeclaration("(*%s_get)" % entry.Name())) 123 if entry.Array(): 124 dcl.extend(entry.AddDeclaration("(*%s_add)" % entry.Name())) 125 self.PrintIndented(filep, " ", dcl) 126 filep.write("};\n\n") 127 128 filep.write("struct %s {\n" % self._name) 129 filep.write(" struct %s_access_ *base;\n\n" % self._name) 130 for entry in self._entries: 131 dcl = entry.Declaration() 132 self.PrintIndented(filep, " ", dcl) 133 filep.write("\n") 134 for entry in self._entries: 135 filep.write(" ev_uint8_t %s_set;\n" % entry.Name()) 136 filep.write("};\n\n") 137 138 filep.write( 139 """struct %(name)s *%(name)s_new(void); 140 struct %(name)s *%(name)s_new_with_arg(void *); 141 void %(name)s_free(struct %(name)s *); 142 void %(name)s_clear(struct %(name)s *); 143 void %(name)s_marshal(struct evbuffer *, const struct %(name)s *); 144 int %(name)s_unmarshal(struct %(name)s *, struct evbuffer *); 145 int %(name)s_complete(struct %(name)s *); 146 void evtag_marshal_%(name)s(struct evbuffer *, ev_uint32_t, 147 const struct %(name)s *); 148 int evtag_unmarshal_%(name)s(struct evbuffer *, ev_uint32_t, 149 struct %(name)s *);\n""" 150 % {"name": self._name} 151 ) 152 153 # Write a setting function of every variable 154 for entry in self._entries: 155 self.PrintIndented( 156 filep, "", entry.AssignDeclaration(entry.AssignFuncName()) 157 ) 158 self.PrintIndented(filep, "", entry.GetDeclaration(entry.GetFuncName())) 159 if entry.Array(): 160 self.PrintIndented(filep, "", entry.AddDeclaration(entry.AddFuncName())) 161 162 filep.write("/* --- %s done --- */\n\n" % self._name) 163 164 def PrintCode(self, filep): 165 filep.write( 166 """/* 167 * Implementation of %s 168 */ 169 """ 170 % (self._name) 171 ) 172 173 filep.write( 174 """ 175 static struct %(name)s_access_ %(name)s_base__ = { 176 """ 177 % {"name": self._name} 178 ) 179 for entry in self._entries: 180 self.PrintIndented(filep, " ", entry.CodeBase()) 181 filep.write("};\n\n") 182 183 # Creation 184 filep.write( 185 """struct %(name)s * 186 %(name)s_new(void) 187 { 188 return %(name)s_new_with_arg(NULL); 189 } 190 191 struct %(name)s * 192 %(name)s_new_with_arg(void *unused) 193 { 194 struct %(name)s *tmp; 195 if ((tmp = malloc(sizeof(struct %(name)s))) == NULL) { 196 event_warn("%%s: malloc", __func__); 197 return (NULL); 198 } 199 tmp->base = &%(name)s_base__; 200 201 """ 202 % {"name": self._name} 203 ) 204 205 for entry in self._entries: 206 self.PrintIndented(filep, " ", entry.CodeInitialize("tmp")) 207 filep.write(" tmp->%s_set = 0;\n\n" % entry.Name()) 208 209 filep.write( 210 """ return (tmp); 211 } 212 213 """ 214 ) 215 216 # Adding 217 for entry in self._entries: 218 if entry.Array(): 219 self.PrintIndented(filep, "", entry.CodeAdd()) 220 filep.write("\n") 221 222 # Assigning 223 for entry in self._entries: 224 self.PrintIndented(filep, "", entry.CodeAssign()) 225 filep.write("\n") 226 227 # Getting 228 for entry in self._entries: 229 self.PrintIndented(filep, "", entry.CodeGet()) 230 filep.write("\n") 231 232 # Clearing 233 filep.write( 234 """void 235 %(name)s_clear(struct %(name)s *tmp) 236 { 237 """ 238 % {"name": self._name} 239 ) 240 for entry in self._entries: 241 self.PrintIndented(filep, " ", entry.CodeClear("tmp")) 242 243 filep.write("}\n\n") 244 245 # Freeing 246 filep.write( 247 """void 248 %(name)s_free(struct %(name)s *tmp) 249 { 250 """ 251 % {"name": self._name} 252 ) 253 254 for entry in self._entries: 255 self.PrintIndented(filep, " ", entry.CodeFree("tmp")) 256 257 filep.write( 258 """ free(tmp); 259 } 260 261 """ 262 ) 263 264 # Marshaling 265 filep.write( 266 """void 267 %(name)s_marshal(struct evbuffer *evbuf, const struct %(name)s *tmp) { 268 """ 269 % {"name": self._name} 270 ) 271 for entry in self._entries: 272 indent = " " 273 # Optional entries do not have to be set 274 if entry.Optional(): 275 indent += " " 276 filep.write(" if (tmp->%s_set) {\n" % entry.Name()) 277 self.PrintIndented( 278 filep, 279 indent, 280 entry.CodeMarshal( 281 "evbuf", 282 self.EntryTagName(entry), 283 entry.GetVarName("tmp"), 284 entry.GetVarLen("tmp"), 285 ), 286 ) 287 if entry.Optional(): 288 filep.write(" }\n") 289 290 filep.write("}\n\n") 291 292 # Unmarshaling 293 filep.write( 294 """int 295 %(name)s_unmarshal(struct %(name)s *tmp, struct evbuffer *evbuf) 296 { 297 ev_uint32_t tag; 298 while (evbuffer_get_length(evbuf) > 0) { 299 if (evtag_peek(evbuf, &tag) == -1) 300 return (-1); 301 switch (tag) { 302 303 """ 304 % {"name": self._name} 305 ) 306 for entry in self._entries: 307 filep.write(" case %s:\n" % (self.EntryTagName(entry))) 308 if not entry.Array(): 309 filep.write( 310 """ if (tmp->%s_set) 311 return (-1); 312 """ 313 % (entry.Name()) 314 ) 315 316 self.PrintIndented( 317 filep, 318 " ", 319 entry.CodeUnmarshal( 320 "evbuf", 321 self.EntryTagName(entry), 322 entry.GetVarName("tmp"), 323 entry.GetVarLen("tmp"), 324 ), 325 ) 326 327 filep.write( 328 """ tmp->%s_set = 1; 329 break; 330 """ 331 % (entry.Name()) 332 ) 333 filep.write( 334 """ default: 335 return -1; 336 } 337 } 338 339 """ 340 ) 341 # Check if it was decoded completely 342 filep.write( 343 """ if (%(name)s_complete(tmp) == -1) 344 return (-1); 345 return (0); 346 } 347 """ 348 % {"name": self._name} 349 ) 350 351 # Checking if a structure has all the required data 352 filep.write( 353 """ 354 int 355 %(name)s_complete(struct %(name)s *msg) 356 { 357 """ 358 % {"name": self._name} 359 ) 360 for entry in self._entries: 361 if not entry.Optional(): 362 code = [ 363 """if (!msg->%(name)s_set) 364 return (-1);""" 365 ] 366 code = TranslateList(code, entry.GetTranslation()) 367 self.PrintIndented(filep, " ", code) 368 369 self.PrintIndented( 370 filep, " ", entry.CodeComplete("msg", entry.GetVarName("msg")) 371 ) 372 filep.write( 373 """ return (0); 374 } 375 """ 376 ) 377 378 # Complete message unmarshaling 379 filep.write( 380 """ 381 int 382 evtag_unmarshal_%(name)s(struct evbuffer *evbuf, ev_uint32_t need_tag, 383 struct %(name)s *msg) 384 { 385 ev_uint32_t tag; 386 int res = -1; 387 388 struct evbuffer *tmp = evbuffer_new(); 389 390 if (evtag_unmarshal(evbuf, &tag, tmp) == -1 || tag != need_tag) 391 goto error; 392 393 if (%(name)s_unmarshal(msg, tmp) == -1) 394 goto error; 395 396 res = 0; 397 398 error: 399 evbuffer_free(tmp); 400 return (res); 401 } 402 """ 403 % {"name": self._name} 404 ) 405 406 # Complete message marshaling 407 filep.write( 408 """ 409 void 410 evtag_marshal_%(name)s(struct evbuffer *evbuf, ev_uint32_t tag, 411 const struct %(name)s *msg) 412 { 413 struct evbuffer *buf_ = evbuffer_new(); 414 assert(buf_ != NULL); 415 %(name)s_marshal(buf_, msg); 416 evtag_marshal_buffer(evbuf, tag, buf_); 417 evbuffer_free(buf_); 418 } 419 420 """ 421 % {"name": self._name} 422 ) 423 424 425 class Entry(object): 426 def __init__(self, ent_type, name, tag): 427 self._type = ent_type 428 self._name = name 429 self._tag = int(tag) 430 self._ctype = ent_type 431 self._optional = False 432 self._can_be_array = False 433 self._array = False 434 self._line_count = -1 435 self._struct = None 436 self._refname = None 437 438 self._optpointer = True 439 self._optaddarg = True 440 441 @staticmethod 442 def GetInitializer(): 443 raise NotImplementedError("Entry does not provide an initializer") 444 445 def SetStruct(self, struct): 446 self._struct = struct 447 448 def LineCount(self): 449 assert self._line_count != -1 450 return self._line_count 451 452 def SetLineCount(self, number): 453 self._line_count = number 454 455 def Array(self): 456 return self._array 457 458 def Optional(self): 459 return self._optional 460 461 def Tag(self): 462 return self._tag 463 464 def Name(self): 465 return self._name 466 467 def Type(self): 468 return self._type 469 470 def MakeArray(self): 471 self._array = True 472 473 def MakeOptional(self): 474 self._optional = True 475 476 def Verify(self): 477 if self.Array() and not self._can_be_array: 478 raise RpcGenError( 479 'Entry "%s" cannot be created as an array ' 480 "around line %d" % (self._name, self.LineCount()) 481 ) 482 if not self._struct: 483 raise RpcGenError( 484 'Entry "%s" does not know which struct it belongs to ' 485 "around line %d" % (self._name, self.LineCount()) 486 ) 487 if self._optional and self._array: 488 raise RpcGenError( 489 'Entry "%s" has illegal combination of optional and array ' 490 "around line %d" % (self._name, self.LineCount()) 491 ) 492 493 def GetTranslation(self, extradict=None): 494 if extradict is None: 495 extradict = {} 496 mapping = { 497 "parent_name": self._struct.Name(), 498 "name": self._name, 499 "ctype": self._ctype, 500 "refname": self._refname, 501 "optpointer": self._optpointer and "*" or "", 502 "optreference": self._optpointer and "&" or "", 503 "optaddarg": self._optaddarg and ", const %s value" % self._ctype or "", 504 } 505 for (k, v) in list(extradict.items()): 506 mapping[k] = v 507 508 return mapping 509 510 def GetVarName(self, var): 511 return "%(var)s->%(name)s_data" % self.GetTranslation({"var": var}) 512 513 def GetVarLen(self, _var): 514 return "sizeof(%s)" % self._ctype 515 516 def GetFuncName(self): 517 return "%s_%s_get" % (self._struct.Name(), self._name) 518 519 def GetDeclaration(self, funcname): 520 code = [ 521 "int %s(struct %s *, %s *);" % (funcname, self._struct.Name(), self._ctype) 522 ] 523 return code 524 525 def CodeGet(self): 526 code = """int 527 %(parent_name)s_%(name)s_get(struct %(parent_name)s *msg, %(ctype)s *value) 528 { 529 if (msg->%(name)s_set != 1) 530 return (-1); 531 *value = msg->%(name)s_data; 532 return (0); 533 }""" 534 code = code % self.GetTranslation() 535 return code.split("\n") 536 537 def AssignFuncName(self): 538 return "%s_%s_assign" % (self._struct.Name(), self._name) 539 540 def AddFuncName(self): 541 return "%s_%s_add" % (self._struct.Name(), self._name) 542 543 def AssignDeclaration(self, funcname): 544 code = [ 545 "int %s(struct %s *, const %s);" 546 % (funcname, self._struct.Name(), self._ctype) 547 ] 548 return code 549 550 def CodeAssign(self): 551 code = [ 552 "int", 553 "%(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg," 554 " const %(ctype)s value)", 555 "{", 556 " msg->%(name)s_set = 1;", 557 " msg->%(name)s_data = value;", 558 " return (0);", 559 "}", 560 ] 561 code = "\n".join(code) 562 code = code % self.GetTranslation() 563 return code.split("\n") 564 565 def CodeClear(self, structname): 566 code = ["%s->%s_set = 0;" % (structname, self.Name())] 567 568 return code 569 570 @staticmethod 571 def CodeComplete(_structname, _var_name): 572 return [] 573 574 @staticmethod 575 def CodeFree(_name): 576 return [] 577 578 def CodeBase(self): 579 code = ["%(parent_name)s_%(name)s_assign,", "%(parent_name)s_%(name)s_get,"] 580 if self.Array(): 581 code.append("%(parent_name)s_%(name)s_add,") 582 583 code = "\n".join(code) 584 code = code % self.GetTranslation() 585 return code.split("\n") 586 587 588 class EntryBytes(Entry): 589 def __init__(self, ent_type, name, tag, length): 590 # Init base class 591 super(EntryBytes, self).__init__(ent_type, name, tag) 592 593 self._length = length 594 self._ctype = "ev_uint8_t" 595 596 @staticmethod 597 def GetInitializer(): 598 return "NULL" 599 600 def GetVarLen(self, _var): 601 return "(%s)" % self._length 602 603 @staticmethod 604 def CodeArrayAdd(varname, _value): 605 # XXX: copy here 606 return ["%(varname)s = NULL;" % {"varname": varname}] 607 608 def GetDeclaration(self, funcname): 609 code = [ 610 "int %s(struct %s *, %s **);" % (funcname, self._struct.Name(), self._ctype) 611 ] 612 return code 613 614 def AssignDeclaration(self, funcname): 615 code = [ 616 "int %s(struct %s *, const %s *);" 617 % (funcname, self._struct.Name(), self._ctype) 618 ] 619 return code 620 621 def Declaration(self): 622 dcl = ["ev_uint8_t %s_data[%s];" % (self._name, self._length)] 623 624 return dcl 625 626 def CodeGet(self): 627 name = self._name 628 code = [ 629 "int", 630 "%s_%s_get(struct %s *msg, %s **value)" 631 % (self._struct.Name(), name, self._struct.Name(), self._ctype), 632 "{", 633 " if (msg->%s_set != 1)" % name, 634 " return (-1);", 635 " *value = msg->%s_data;" % name, 636 " return (0);", 637 "}", 638 ] 639 return code 640 641 def CodeAssign(self): 642 name = self._name 643 code = [ 644 "int", 645 "%s_%s_assign(struct %s *msg, const %s *value)" 646 % (self._struct.Name(), name, self._struct.Name(), self._ctype), 647 "{", 648 " msg->%s_set = 1;" % name, 649 " memcpy(msg->%s_data, value, %s);" % (name, self._length), 650 " return (0);", 651 "}", 652 ] 653 return code 654 655 def CodeUnmarshal(self, buf, tag_name, var_name, var_len): 656 code = [ 657 "if (evtag_unmarshal_fixed(%(buf)s, %(tag)s, " 658 "%(var)s, %(varlen)s) == -1) {", 659 ' event_warnx("%%s: failed to unmarshal %(name)s", __func__);', 660 " return (-1);", 661 "}", 662 ] 663 return TranslateList( 664 code, 665 self.GetTranslation( 666 {"var": var_name, "varlen": var_len, "buf": buf, "tag": tag_name} 667 ), 668 ) 669 670 @staticmethod 671 def CodeMarshal(buf, tag_name, var_name, var_len): 672 code = ["evtag_marshal(%s, %s, %s, %s);" % (buf, tag_name, var_name, var_len)] 673 return code 674 675 def CodeClear(self, structname): 676 code = [ 677 "%s->%s_set = 0;" % (structname, self.Name()), 678 "memset(%s->%s_data, 0, sizeof(%s->%s_data));" 679 % (structname, self._name, structname, self._name), 680 ] 681 682 return code 683 684 def CodeInitialize(self, name): 685 code = [ 686 "memset(%s->%s_data, 0, sizeof(%s->%s_data));" 687 % (name, self._name, name, self._name) 688 ] 689 return code 690 691 def Verify(self): 692 if not self._length: 693 raise RpcGenError( 694 'Entry "%s" needs a length ' 695 "around line %d" % (self._name, self.LineCount()) 696 ) 697 698 super(EntryBytes, self).Verify() 699 700 701 class EntryInt(Entry): 702 def __init__(self, ent_type, name, tag, bits=32): 703 # Init base class 704 super(EntryInt, self).__init__(ent_type, name, tag) 705 706 self._can_be_array = True 707 if bits == 32: 708 self._ctype = "ev_uint32_t" 709 self._marshal_type = "int" 710 if bits == 64: 711 self._ctype = "ev_uint64_t" 712 self._marshal_type = "int64" 713 714 @staticmethod 715 def GetInitializer(): 716 return "0" 717 718 @staticmethod 719 def CodeArrayFree(_var): 720 return [] 721 722 @staticmethod 723 def CodeArrayAssign(varname, srcvar): 724 return ["%(varname)s = %(srcvar)s;" % {"varname": varname, "srcvar": srcvar}] 725 726 @staticmethod 727 def CodeArrayAdd(varname, value): 728 """Returns a new entry of this type.""" 729 return ["%(varname)s = %(value)s;" % {"varname": varname, "value": value}] 730 731 def CodeUnmarshal(self, buf, tag_name, var_name, _var_len): 732 code = [ 733 "if (evtag_unmarshal_%(ma)s(%(buf)s, %(tag)s, &%(var)s) == -1) {", 734 ' event_warnx("%%s: failed to unmarshal %(name)s", __func__);', 735 " return (-1);", 736 "}", 737 ] 738 code = "\n".join(code) % self.GetTranslation( 739 {"ma": self._marshal_type, "buf": buf, "tag": tag_name, "var": var_name} 740 ) 741 return code.split("\n") 742 743 def CodeMarshal(self, buf, tag_name, var_name, _var_len): 744 code = [ 745 "evtag_marshal_%s(%s, %s, %s);" 746 % (self._marshal_type, buf, tag_name, var_name) 747 ] 748 return code 749 750 def Declaration(self): 751 dcl = ["%s %s_data;" % (self._ctype, self._name)] 752 753 return dcl 754 755 def CodeInitialize(self, name): 756 code = ["%s->%s_data = 0;" % (name, self._name)] 757 return code 758 759 760 class EntryString(Entry): 761 def __init__(self, ent_type, name, tag): 762 # Init base class 763 super(EntryString, self).__init__(ent_type, name, tag) 764 765 self._can_be_array = True 766 self._ctype = "char *" 767 768 @staticmethod 769 def GetInitializer(): 770 return "NULL" 771 772 @staticmethod 773 def CodeArrayFree(varname): 774 code = ["if (%(var)s != NULL) free(%(var)s);"] 775 776 return TranslateList(code, {"var": varname}) 777 778 @staticmethod 779 def CodeArrayAssign(varname, srcvar): 780 code = [ 781 "if (%(var)s != NULL)", 782 " free(%(var)s);", 783 "%(var)s = strdup(%(srcvar)s);", 784 "if (%(var)s == NULL) {", 785 ' event_warnx("%%s: strdup", __func__);', 786 " return (-1);", 787 "}", 788 ] 789 790 return TranslateList(code, {"var": varname, "srcvar": srcvar}) 791 792 @staticmethod 793 def CodeArrayAdd(varname, value): 794 code = [ 795 "if (%(value)s != NULL) {", 796 " %(var)s = strdup(%(value)s);", 797 " if (%(var)s == NULL) {", 798 " goto error;", 799 " }", 800 "} else {", 801 " %(var)s = NULL;", 802 "}", 803 ] 804 805 return TranslateList(code, {"var": varname, "value": value}) 806 807 def GetVarLen(self, var): 808 return "strlen(%s)" % self.GetVarName(var) 809 810 @staticmethod 811 def CodeMakeInitalize(varname): 812 return "%(varname)s = NULL;" % {"varname": varname} 813 814 def CodeAssign(self): 815 code = """int 816 %(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg, 817 const %(ctype)s value) 818 { 819 if (msg->%(name)s_data != NULL) 820 free(msg->%(name)s_data); 821 if ((msg->%(name)s_data = strdup(value)) == NULL) 822 return (-1); 823 msg->%(name)s_set = 1; 824 return (0); 825 }""" % ( 826 self.GetTranslation() 827 ) 828 829 return code.split("\n") 830 831 def CodeUnmarshal(self, buf, tag_name, var_name, _var_len): 832 code = [ 833 "if (evtag_unmarshal_string(%(buf)s, %(tag)s, &%(var)s) == -1) {", 834 ' event_warnx("%%s: failed to unmarshal %(name)s", __func__);', 835 " return (-1);", 836 "}", 837 ] 838 code = "\n".join(code) % self.GetTranslation( 839 {"buf": buf, "tag": tag_name, "var": var_name} 840 ) 841 return code.split("\n") 842 843 @staticmethod 844 def CodeMarshal(buf, tag_name, var_name, _var_len): 845 code = ["evtag_marshal_string(%s, %s, %s);" % (buf, tag_name, var_name)] 846 return code 847 848 def CodeClear(self, structname): 849 code = [ 850 "if (%s->%s_set == 1) {" % (structname, self.Name()), 851 " free(%s->%s_data);" % (structname, self.Name()), 852 " %s->%s_data = NULL;" % (structname, self.Name()), 853 " %s->%s_set = 0;" % (structname, self.Name()), 854 "}", 855 ] 856 857 return code 858 859 def CodeInitialize(self, name): 860 code = ["%s->%s_data = NULL;" % (name, self._name)] 861 return code 862 863 def CodeFree(self, name): 864 code = [ 865 "if (%s->%s_data != NULL)" % (name, self._name), 866 " free (%s->%s_data);" % (name, self._name), 867 ] 868 869 return code 870 871 def Declaration(self): 872 dcl = ["char *%s_data;" % self._name] 873 874 return dcl 875 876 877 class EntryStruct(Entry): 878 def __init__(self, ent_type, name, tag, refname): 879 # Init base class 880 super(EntryStruct, self).__init__(ent_type, name, tag) 881 882 self._optpointer = False 883 self._can_be_array = True 884 self._refname = refname 885 self._ctype = "struct %s*" % refname 886 self._optaddarg = False 887 888 def GetInitializer(self): 889 return "NULL" 890 891 def GetVarLen(self, _var): 892 return "-1" 893 894 def CodeArrayAdd(self, varname, _value): 895 code = [ 896 "%(varname)s = %(refname)s_new();", 897 "if (%(varname)s == NULL)", 898 " goto error;", 899 ] 900 901 return TranslateList(code, self.GetTranslation({"varname": varname})) 902 903 def CodeArrayFree(self, var): 904 code = ["%(refname)s_free(%(var)s);" % self.GetTranslation({"var": var})] 905 return code 906 907 def CodeArrayAssign(self, var, srcvar): 908 code = [ 909 "int had_error = 0;", 910 "struct evbuffer *tmp = NULL;", 911 "%(refname)s_clear(%(var)s);", 912 "if ((tmp = evbuffer_new()) == NULL) {", 913 ' event_warn("%%s: evbuffer_new()", __func__);', 914 " had_error = 1;", 915 " goto done;", 916 "}", 917 "%(refname)s_marshal(tmp, %(srcvar)s);", 918 "if (%(refname)s_unmarshal(%(var)s, tmp) == -1) {", 919 ' event_warnx("%%s: %(refname)s_unmarshal", __func__);', 920 " had_error = 1;", 921 " goto done;", 922 "}", 923 "done:", 924 "if (tmp != NULL)", 925 " evbuffer_free(tmp);", 926 "if (had_error) {", 927 " %(refname)s_clear(%(var)s);", 928 " return (-1);", 929 "}", 930 ] 931 932 return TranslateList(code, self.GetTranslation({"var": var, "srcvar": srcvar})) 933 934 def CodeGet(self): 935 name = self._name 936 code = [ 937 "int", 938 "%s_%s_get(struct %s *msg, %s *value)" 939 % (self._struct.Name(), name, self._struct.Name(), self._ctype), 940 "{", 941 " if (msg->%s_set != 1) {" % name, 942 " msg->%s_data = %s_new();" % (name, self._refname), 943 " if (msg->%s_data == NULL)" % name, 944 " return (-1);", 945 " msg->%s_set = 1;" % name, 946 " }", 947 " *value = msg->%s_data;" % name, 948 " return (0);", 949 "}", 950 ] 951 return code 952 953 def CodeAssign(self): 954 code = ( 955 """int 956 %(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg, 957 const %(ctype)s value) 958 { 959 struct evbuffer *tmp = NULL; 960 if (msg->%(name)s_set) { 961 %(refname)s_clear(msg->%(name)s_data); 962 msg->%(name)s_set = 0; 963 } else { 964 msg->%(name)s_data = %(refname)s_new(); 965 if (msg->%(name)s_data == NULL) { 966 event_warn("%%s: %(refname)s_new()", __func__); 967 goto error; 968 } 969 } 970 if ((tmp = evbuffer_new()) == NULL) { 971 event_warn("%%s: evbuffer_new()", __func__); 972 goto error; 973 } 974 %(refname)s_marshal(tmp, value); 975 if (%(refname)s_unmarshal(msg->%(name)s_data, tmp) == -1) { 976 event_warnx("%%s: %(refname)s_unmarshal", __func__); 977 goto error; 978 } 979 msg->%(name)s_set = 1; 980 evbuffer_free(tmp); 981 return (0); 982 error: 983 if (tmp != NULL) 984 evbuffer_free(tmp); 985 if (msg->%(name)s_data != NULL) { 986 %(refname)s_free(msg->%(name)s_data); 987 msg->%(name)s_data = NULL; 988 } 989 return (-1); 990 }""" 991 % self.GetTranslation() 992 ) 993 return code.split("\n") 994 995 def CodeComplete(self, structname, var_name): 996 code = [ 997 "if (%(structname)s->%(name)s_set && " 998 "%(refname)s_complete(%(var)s) == -1)", 999 " return (-1);", 1000 ] 1001 1002 return TranslateList( 1003 code, self.GetTranslation({"structname": structname, "var": var_name}) 1004 ) 1005 1006 def CodeUnmarshal(self, buf, tag_name, var_name, _var_len): 1007 code = [ 1008 "%(var)s = %(refname)s_new();", 1009 "if (%(var)s == NULL)", 1010 " return (-1);", 1011 "if (evtag_unmarshal_%(refname)s(%(buf)s, %(tag)s, ", 1012 " %(var)s) == -1) {", 1013 ' event_warnx("%%s: failed to unmarshal %(name)s", __func__);', 1014 " return (-1);", 1015 "}", 1016 ] 1017 code = "\n".join(code) % self.GetTranslation( 1018 {"buf": buf, "tag": tag_name, "var": var_name} 1019 ) 1020 return code.split("\n") 1021 1022 def CodeMarshal(self, buf, tag_name, var_name, _var_len): 1023 code = [ 1024 "evtag_marshal_%s(%s, %s, %s);" % (self._refname, buf, tag_name, var_name) 1025 ] 1026 return code 1027 1028 def CodeClear(self, structname): 1029 code = [ 1030 "if (%s->%s_set == 1) {" % (structname, self.Name()), 1031 " %s_free(%s->%s_data);" % (self._refname, structname, self.Name()), 1032 " %s->%s_data = NULL;" % (structname, self.Name()), 1033 " %s->%s_set = 0;" % (structname, self.Name()), 1034 "}", 1035 ] 1036 1037 return code 1038 1039 def CodeInitialize(self, name): 1040 code = ["%s->%s_data = NULL;" % (name, self._name)] 1041 return code 1042 1043 def CodeFree(self, name): 1044 code = [ 1045 "if (%s->%s_data != NULL)" % (name, self._name), 1046 " %s_free(%s->%s_data);" % (self._refname, name, self._name), 1047 ] 1048 1049 return code 1050 1051 def Declaration(self): 1052 dcl = ["%s %s_data;" % (self._ctype, self._name)] 1053 1054 return dcl 1055 1056 1057 class EntryVarBytes(Entry): 1058 def __init__(self, ent_type, name, tag): 1059 # Init base class 1060 super(EntryVarBytes, self).__init__(ent_type, name, tag) 1061 1062 self._ctype = "ev_uint8_t *" 1063 1064 @staticmethod 1065 def GetInitializer(): 1066 return "NULL" 1067 1068 def GetVarLen(self, var): 1069 return "%(var)s->%(name)s_length" % self.GetTranslation({"var": var}) 1070 1071 @staticmethod 1072 def CodeArrayAdd(varname, _value): 1073 # xxx: copy 1074 return ["%(varname)s = NULL;" % {"varname": varname}] 1075 1076 def GetDeclaration(self, funcname): 1077 code = [ 1078 "int %s(struct %s *, %s *, ev_uint32_t *);" 1079 % (funcname, self._struct.Name(), self._ctype) 1080 ] 1081 return code 1082 1083 def AssignDeclaration(self, funcname): 1084 code = [ 1085 "int %s(struct %s *, const %s, ev_uint32_t);" 1086 % (funcname, self._struct.Name(), self._ctype) 1087 ] 1088 return code 1089 1090 def CodeAssign(self): 1091 name = self._name 1092 code = [ 1093 "int", 1094 "%s_%s_assign(struct %s *msg, " 1095 "const %s value, ev_uint32_t len)" 1096 % (self._struct.Name(), name, self._struct.Name(), self._ctype), 1097 "{", 1098 " if (msg->%s_data != NULL)" % name, 1099 " free (msg->%s_data);" % name, 1100 " msg->%s_data = malloc(len);" % name, 1101 " if (msg->%s_data == NULL)" % name, 1102 " return (-1);", 1103 " msg->%s_set = 1;" % name, 1104 " msg->%s_length = len;" % name, 1105 " memcpy(msg->%s_data, value, len);" % name, 1106 " return (0);", 1107 "}", 1108 ] 1109 return code 1110 1111 def CodeGet(self): 1112 name = self._name 1113 code = [ 1114 "int", 1115 "%s_%s_get(struct %s *msg, %s *value, ev_uint32_t *plen)" 1116 % (self._struct.Name(), name, self._struct.Name(), self._ctype), 1117 "{", 1118 " if (msg->%s_set != 1)" % name, 1119 " return (-1);", 1120 " *value = msg->%s_data;" % name, 1121 " *plen = msg->%s_length;" % name, 1122 " return (0);", 1123 "}", 1124 ] 1125 return code 1126 1127 def CodeUnmarshal(self, buf, tag_name, var_name, var_len): 1128 code = [ 1129 "if (evtag_payload_length(%(buf)s, &%(varlen)s) == -1)", 1130 " return (-1);", 1131 # We do not want DoS opportunities 1132 "if (%(varlen)s > evbuffer_get_length(%(buf)s))", 1133 " return (-1);", 1134 "if ((%(var)s = malloc(%(varlen)s)) == NULL)", 1135 " return (-1);", 1136 "if (evtag_unmarshal_fixed(%(buf)s, %(tag)s, %(var)s, " 1137 "%(varlen)s) == -1) {", 1138 ' event_warnx("%%s: failed to unmarshal %(name)s", __func__);', 1139 " return (-1);", 1140 "}", 1141 ] 1142 code = "\n".join(code) % self.GetTranslation( 1143 {"buf": buf, "tag": tag_name, "var": var_name, "varlen": var_len} 1144 ) 1145 return code.split("\n") 1146 1147 @staticmethod 1148 def CodeMarshal(buf, tag_name, var_name, var_len): 1149 code = ["evtag_marshal(%s, %s, %s, %s);" % (buf, tag_name, var_name, var_len)] 1150 return code 1151 1152 def CodeClear(self, structname): 1153 code = [ 1154 "if (%s->%s_set == 1) {" % (structname, self.Name()), 1155 " free (%s->%s_data);" % (structname, self.Name()), 1156 " %s->%s_data = NULL;" % (structname, self.Name()), 1157 " %s->%s_length = 0;" % (structname, self.Name()), 1158 " %s->%s_set = 0;" % (structname, self.Name()), 1159 "}", 1160 ] 1161 1162 return code 1163 1164 def CodeInitialize(self, name): 1165 code = [ 1166 "%s->%s_data = NULL;" % (name, self._name), 1167 "%s->%s_length = 0;" % (name, self._name), 1168 ] 1169 return code 1170 1171 def CodeFree(self, name): 1172 code = [ 1173 "if (%s->%s_data != NULL)" % (name, self._name), 1174 " free(%s->%s_data);" % (name, self._name), 1175 ] 1176 1177 return code 1178 1179 def Declaration(self): 1180 dcl = [ 1181 "ev_uint8_t *%s_data;" % self._name, 1182 "ev_uint32_t %s_length;" % self._name, 1183 ] 1184 1185 return dcl 1186 1187 1188 class EntryArray(Entry): 1189 _index = None 1190 1191 def __init__(self, entry): 1192 # Init base class 1193 super(EntryArray, self).__init__(entry._type, entry._name, entry._tag) 1194 1195 self._entry = entry 1196 self._refname = entry._refname 1197 self._ctype = self._entry._ctype 1198 self._optional = True 1199 self._optpointer = self._entry._optpointer 1200 self._optaddarg = self._entry._optaddarg 1201 1202 # provide a new function for accessing the variable name 1203 def GetVarName(var_name): 1204 return "%(var)s->%(name)s_data[%(index)s]" % self._entry.GetTranslation( 1205 {"var": var_name, "index": self._index} 1206 ) 1207 1208 self._entry.GetVarName = GetVarName 1209 1210 def GetInitializer(self): 1211 return "NULL" 1212 1213 def GetVarName(self, var): 1214 return var 1215 1216 def GetVarLen(self, _var_name): 1217 return "-1" 1218 1219 def GetDeclaration(self, funcname): 1220 """Allows direct access to elements of the array.""" 1221 code = [ 1222 "int %(funcname)s(struct %(parent_name)s *, int, %(ctype)s *);" 1223 % self.GetTranslation({"funcname": funcname}) 1224 ] 1225 return code 1226 1227 def AssignDeclaration(self, funcname): 1228 code = [ 1229 "int %s(struct %s *, int, const %s);" 1230 % (funcname, self._struct.Name(), self._ctype) 1231 ] 1232 return code 1233 1234 def AddDeclaration(self, funcname): 1235 code = [ 1236 "%(ctype)s %(optpointer)s " 1237 "%(funcname)s(struct %(parent_name)s *msg%(optaddarg)s);" 1238 % self.GetTranslation({"funcname": funcname}) 1239 ] 1240 return code 1241 1242 def CodeGet(self): 1243 code = """int 1244 %(parent_name)s_%(name)s_get(struct %(parent_name)s *msg, int offset, 1245 %(ctype)s *value) 1246 { 1247 if (!msg->%(name)s_set || offset < 0 || offset >= msg->%(name)s_length) 1248 return (-1); 1249 *value = msg->%(name)s_data[offset]; 1250 return (0); 1251 } 1252 """ % ( 1253 self.GetTranslation() 1254 ) 1255 1256 return code.splitlines() 1257 1258 def CodeAssign(self): 1259 code = [ 1260 "int", 1261 "%(parent_name)s_%(name)s_assign(struct %(parent_name)s *msg, int off,", 1262 " const %(ctype)s value)", 1263 "{", 1264 " if (!msg->%(name)s_set || off < 0 || off >= msg->%(name)s_length)", 1265 " return (-1);", 1266 "", 1267 " {", 1268 ] 1269 code = TranslateList(code, self.GetTranslation()) 1270 1271 codearrayassign = self._entry.CodeArrayAssign( 1272 "msg->%(name)s_data[off]" % self.GetTranslation(), "value" 1273 ) 1274 code += [" " + x for x in codearrayassign] 1275 1276 code += TranslateList([" }", " return (0);", "}"], self.GetTranslation()) 1277 1278 return code 1279 1280 def CodeAdd(self): 1281 codearrayadd = self._entry.CodeArrayAdd( 1282 "msg->%(name)s_data[msg->%(name)s_length - 1]" % self.GetTranslation(), 1283 "value", 1284 ) 1285 code = [ 1286 "static int", 1287 "%(parent_name)s_%(name)s_expand_to_hold_more(" 1288 "struct %(parent_name)s *msg)", 1289 "{", 1290 " int tobe_allocated = msg->%(name)s_num_allocated;", 1291 " %(ctype)s* new_data = NULL;", 1292 " tobe_allocated = !tobe_allocated ? 1 : tobe_allocated << 1;", 1293 " new_data = (%(ctype)s*) realloc(msg->%(name)s_data,", 1294 " tobe_allocated * sizeof(%(ctype)s));", 1295 " if (new_data == NULL)", 1296 " return -1;", 1297 " msg->%(name)s_data = new_data;", 1298 " msg->%(name)s_num_allocated = tobe_allocated;", 1299 " return 0;", 1300 "}", 1301 "", 1302 "%(ctype)s %(optpointer)s", 1303 "%(parent_name)s_%(name)s_add(struct %(parent_name)s *msg%(optaddarg)s)", 1304 "{", 1305 " if (++msg->%(name)s_length >= msg->%(name)s_num_allocated) {", 1306 " if (%(parent_name)s_%(name)s_expand_to_hold_more(msg)<0)", 1307 " goto error;", 1308 " }", 1309 ] 1310 1311 code = TranslateList(code, self.GetTranslation()) 1312 1313 code += [" " + x for x in codearrayadd] 1314 1315 code += TranslateList( 1316 [ 1317 " msg->%(name)s_set = 1;", 1318 " return %(optreference)s(msg->%(name)s_data[" 1319 "msg->%(name)s_length - 1]);", 1320 "error:", 1321 " --msg->%(name)s_length;", 1322 " return (NULL);", 1323 "}", 1324 ], 1325 self.GetTranslation(), 1326 ) 1327 1328 return code 1329 1330 def CodeComplete(self, structname, var_name): 1331 self._index = "i" 1332 tmp = self._entry.CodeComplete(structname, self._entry.GetVarName(var_name)) 1333 # skip the whole loop if there is nothing to check 1334 if not tmp: 1335 return [] 1336 1337 translate = self.GetTranslation({"structname": structname}) 1338 code = [ 1339 "{", 1340 " int i;", 1341 " for (i = 0; i < %(structname)s->%(name)s_length; ++i) {", 1342 ] 1343 1344 code = TranslateList(code, translate) 1345 1346 code += [" " + x for x in tmp] 1347 1348 code += [" }", "}"] 1349 1350 return code 1351 1352 def CodeUnmarshal(self, buf, tag_name, var_name, _var_len): 1353 translate = self.GetTranslation( 1354 { 1355 "var": var_name, 1356 "buf": buf, 1357 "tag": tag_name, 1358 "init": self._entry.GetInitializer(), 1359 } 1360 ) 1361 code = [ 1362 "if (%(var)s->%(name)s_length >= %(var)s->%(name)s_num_allocated &&", 1363 " %(parent_name)s_%(name)s_expand_to_hold_more(%(var)s) < 0) {", 1364 ' puts("HEY NOW");', 1365 " return (-1);", 1366 "}", 1367 ] 1368 1369 # the unmarshal code directly returns 1370 code = TranslateList(code, translate) 1371 1372 self._index = "%(var)s->%(name)s_length" % translate 1373 code += self._entry.CodeUnmarshal( 1374 buf, 1375 tag_name, 1376 self._entry.GetVarName(var_name), 1377 self._entry.GetVarLen(var_name), 1378 ) 1379 1380 code += ["++%(var)s->%(name)s_length;" % translate] 1381 1382 return code 1383 1384 def CodeMarshal(self, buf, tag_name, var_name, _var_len): 1385 code = ["{", " int i;", " for (i = 0; i < %(var)s->%(name)s_length; ++i) {"] 1386 1387 self._index = "i" 1388 code += self._entry.CodeMarshal( 1389 buf, 1390 tag_name, 1391 self._entry.GetVarName(var_name), 1392 self._entry.GetVarLen(var_name), 1393 ) 1394 code += [" }", "}"] 1395 1396 code = "\n".join(code) % self.GetTranslation({"var": var_name}) 1397 1398 return code.split("\n") 1399 1400 def CodeClear(self, structname): 1401 translate = self.GetTranslation({"structname": structname}) 1402 codearrayfree = self._entry.CodeArrayFree( 1403 "%(structname)s->%(name)s_data[i]" 1404 % self.GetTranslation({"structname": structname}) 1405 ) 1406 1407 code = ["if (%(structname)s->%(name)s_set == 1) {"] 1408 1409 if codearrayfree: 1410 code += [ 1411 " int i;", 1412 " for (i = 0; i < %(structname)s->%(name)s_length; ++i) {", 1413 ] 1414 1415 code = TranslateList(code, translate) 1416 1417 if codearrayfree: 1418 code += [" " + x for x in codearrayfree] 1419 code += [" }"] 1420 1421 code += TranslateList( 1422 [ 1423 " free(%(structname)s->%(name)s_data);", 1424 " %(structname)s->%(name)s_data = NULL;", 1425 " %(structname)s->%(name)s_set = 0;", 1426 " %(structname)s->%(name)s_length = 0;", 1427 " %(structname)s->%(name)s_num_allocated = 0;", 1428 "}", 1429 ], 1430 translate, 1431 ) 1432 1433 return code 1434 1435 def CodeInitialize(self, name): 1436 code = [ 1437 "%s->%s_data = NULL;" % (name, self._name), 1438 "%s->%s_length = 0;" % (name, self._name), 1439 "%s->%s_num_allocated = 0;" % (name, self._name), 1440 ] 1441 return code 1442 1443 def CodeFree(self, structname): 1444 code = self.CodeClear(structname) 1445 1446 code += TranslateList( 1447 ["free(%(structname)s->%(name)s_data);"], 1448 self.GetTranslation({"structname": structname}), 1449 ) 1450 1451 return code 1452 1453 def Declaration(self): 1454 dcl = [ 1455 "%s *%s_data;" % (self._ctype, self._name), 1456 "int %s_length;" % self._name, 1457 "int %s_num_allocated;" % self._name, 1458 ] 1459 1460 return dcl 1461 1462 1463 def NormalizeLine(line): 1464 1465 line = CPPCOMMENT_RE.sub("", line) 1466 line = line.strip() 1467 line = WHITESPACE_RE.sub(" ", line) 1468 1469 return line 1470 1471 1472 ENTRY_NAME_RE = re.compile(r"(?P<name>[^\[\]]+)(\[(?P<fixed_length>.*)\])?") 1473 ENTRY_TAG_NUMBER_RE = re.compile(r"(0x)?\d+", re.I) 1474 1475 1476 def ProcessOneEntry(factory, newstruct, entry): 1477 optional = False 1478 array = False 1479 entry_type = "" 1480 name = "" 1481 tag = "" 1482 tag_set = None 1483 separator = "" 1484 fixed_length = "" 1485 1486 for token in entry.split(" "): 1487 if not entry_type: 1488 if not optional and token == "optional": 1489 optional = True 1490 continue 1491 1492 if not array and token == "array": 1493 array = True 1494 continue 1495 1496 if not entry_type: 1497 entry_type = token 1498 continue 1499 1500 if not name: 1501 res = ENTRY_NAME_RE.match(token) 1502 if not res: 1503 raise RpcGenError( 1504 r"""Cannot parse name: "%s" around line %d""" % (entry, LINE_COUNT) 1505 ) 1506 name = res.group("name") 1507 fixed_length = res.group("fixed_length") 1508 continue 1509 1510 if not separator: 1511 separator = token 1512 if separator != "=": 1513 raise RpcGenError( 1514 r'''Expected "=" after name "%s" got "%s"''' % (name, token) 1515 ) 1516 continue 1517 1518 if not tag_set: 1519 tag_set = 1 1520 if not ENTRY_TAG_NUMBER_RE.match(token): 1521 raise RpcGenError(r'''Expected tag number: "%s"''' % (entry)) 1522 tag = int(token, 0) 1523 continue 1524 1525 raise RpcGenError(r'''Cannot parse "%s"''' % (entry)) 1526 1527 if not tag_set: 1528 raise RpcGenError(r'''Need tag number: "%s"''' % (entry)) 1529 1530 # Create the right entry 1531 if entry_type == "bytes": 1532 if fixed_length: 1533 newentry = factory.EntryBytes(entry_type, name, tag, fixed_length) 1534 else: 1535 newentry = factory.EntryVarBytes(entry_type, name, tag) 1536 elif entry_type == "int" and not fixed_length: 1537 newentry = factory.EntryInt(entry_type, name, tag) 1538 elif entry_type == "int64" and not fixed_length: 1539 newentry = factory.EntryInt(entry_type, name, tag, bits=64) 1540 elif entry_type == "string" and not fixed_length: 1541 newentry = factory.EntryString(entry_type, name, tag) 1542 else: 1543 res = STRUCT_REF_RE.match(entry_type) 1544 if res: 1545 # References another struct defined in our file 1546 newentry = factory.EntryStruct(entry_type, name, tag, res.group("name")) 1547 else: 1548 raise RpcGenError('Bad type: "%s" in "%s"' % (entry_type, entry)) 1549 1550 structs = [] 1551 1552 if optional: 1553 newentry.MakeOptional() 1554 if array: 1555 newentry.MakeArray() 1556 1557 newentry.SetStruct(newstruct) 1558 newentry.SetLineCount(LINE_COUNT) 1559 newentry.Verify() 1560 1561 if array: 1562 # We need to encapsulate this entry into a struct 1563 newentry = factory.EntryArray(newentry) 1564 newentry.SetStruct(newstruct) 1565 newentry.SetLineCount(LINE_COUNT) 1566 newentry.MakeArray() 1567 1568 newstruct.AddEntry(newentry) 1569 1570 return structs 1571 1572 1573 def ProcessStruct(factory, data): 1574 tokens = data.split(" ") 1575 1576 # First three tokens are: 'struct' 'name' '{' 1577 newstruct = factory.Struct(tokens[1]) 1578 1579 inside = " ".join(tokens[3:-1]) 1580 1581 tokens = inside.split(";") 1582 1583 structs = [] 1584 1585 for entry in tokens: 1586 entry = NormalizeLine(entry) 1587 if not entry: 1588 continue 1589 1590 # It's possible that new structs get defined in here 1591 structs.extend(ProcessOneEntry(factory, newstruct, entry)) 1592 1593 structs.append(newstruct) 1594 return structs 1595 1596 1597 C_COMMENT_START = "/*" 1598 C_COMMENT_END = "*/" 1599 1600 C_COMMENT_START_RE = re.compile(re.escape(C_COMMENT_START)) 1601 C_COMMENT_END_RE = re.compile(re.escape(C_COMMENT_END)) 1602 1603 C_COMMENT_START_SUB_RE = re.compile(r"%s.*$" % (re.escape(C_COMMENT_START))) 1604 C_COMMENT_END_SUB_RE = re.compile(r"%s.*$" % (re.escape(C_COMMENT_END))) 1605 1606 C_MULTILINE_COMMENT_SUB_RE = re.compile( 1607 r"%s.*?%s" % (re.escape(C_COMMENT_START), re.escape(C_COMMENT_END)) 1608 ) 1609 CPP_CONDITIONAL_BLOCK_RE = re.compile(r"#(if( |def)|endif)") 1610 INCLUDE_RE = re.compile(r'#include (".+"|<.+>)') 1611 1612 1613 def GetNextStruct(filep): 1614 global CPP_DIRECT 1615 global LINE_COUNT 1616 1617 got_struct = False 1618 have_c_comment = False 1619 1620 data = "" 1621 1622 while True: 1623 line = filep.readline() 1624 if not line: 1625 break 1626 1627 LINE_COUNT += 1 1628 line = line[:-1] 1629 1630 if not have_c_comment and C_COMMENT_START_RE.search(line): 1631 if C_MULTILINE_COMMENT_SUB_RE.search(line): 1632 line = C_MULTILINE_COMMENT_SUB_RE.sub("", line) 1633 else: 1634 line = C_COMMENT_START_SUB_RE.sub("", line) 1635 have_c_comment = True 1636 1637 if have_c_comment: 1638 if not C_COMMENT_END_RE.search(line): 1639 continue 1640 have_c_comment = False 1641 line = C_COMMENT_END_SUB_RE.sub("", line) 1642 1643 line = NormalizeLine(line) 1644 1645 if not line: 1646 continue 1647 1648 if not got_struct: 1649 if INCLUDE_RE.match(line): 1650 CPP_DIRECT.append(line) 1651 elif CPP_CONDITIONAL_BLOCK_RE.match(line): 1652 CPP_DIRECT.append(line) 1653 elif PREPROCESSOR_DEF_RE.match(line): 1654 HEADER_DIRECT.append(line) 1655 elif not STRUCT_DEF_RE.match(line): 1656 raise RpcGenError("Missing struct on line %d: %s" % (LINE_COUNT, line)) 1657 else: 1658 got_struct = True 1659 data += line 1660 continue 1661 1662 # We are inside the struct 1663 tokens = line.split("}") 1664 if len(tokens) == 1: 1665 data += " " + line 1666 continue 1667 1668 if tokens[1]: 1669 raise RpcGenError("Trailing garbage after struct on line %d" % LINE_COUNT) 1670 1671 # We found the end of the struct 1672 data += " %s}" % tokens[0] 1673 break 1674 1675 # Remove any comments, that might be in there 1676 data = re.sub(r"/\*.*\*/", "", data) 1677 1678 return data 1679 1680 1681 def Parse(factory, filep): 1682 """ 1683 Parses the input file and returns C code and corresponding header file. 1684 """ 1685 1686 entities = [] 1687 1688 while 1: 1689 # Just gets the whole struct nicely formatted 1690 data = GetNextStruct(filep) 1691 1692 if not data: 1693 break 1694 1695 entities.extend(ProcessStruct(factory, data)) 1696 1697 return entities 1698 1699 1700 class CCodeGenerator(object): 1701 def __init__(self): 1702 pass 1703 1704 @staticmethod 1705 def GuardName(name): 1706 # Use the complete provided path to the input file, with all 1707 # non-identifier characters replaced with underscores, to 1708 # reduce the chance of a collision between guard macros. 1709 return "EVENT_RPCOUT_%s_" % (NONIDENT_RE.sub("_", name).upper()) 1710 1711 def HeaderPreamble(self, name): 1712 guard = self.GuardName(name) 1713 pre = """ 1714 /* 1715 * Automatically generated from %s 1716 */ 1717 1718 #ifndef %s 1719 #define %s 1720 1721 """ % ( 1722 name, 1723 guard, 1724 guard, 1725 ) 1726 1727 if HEADER_DIRECT: 1728 for statement in HEADER_DIRECT: 1729 pre += "%s\n" % statement 1730 pre += "\n" 1731 1732 pre += """ 1733 #include <event2/util.h> /* for ev_uint*_t */ 1734 #include <event2/rpc.h> 1735 """ 1736 1737 return pre 1738 1739 def HeaderPostamble(self, name): 1740 guard = self.GuardName(name) 1741 return "#endif /* %s */" % (guard) 1742 1743 @staticmethod 1744 def BodyPreamble(name, header_file): 1745 global _NAME 1746 global _VERSION 1747 1748 slash = header_file.rfind("/") 1749 if slash != -1: 1750 header_file = header_file[slash + 1 :] 1751 1752 pre = """ 1753 /* 1754 * Automatically generated from %(name)s 1755 * by %(script_name)s/%(script_version)s. DO NOT EDIT THIS FILE. 1756 */ 1757 1758 #include <stdlib.h> 1759 #include <string.h> 1760 #include <assert.h> 1761 #include <event2/event-config.h> 1762 #include <event2/event.h> 1763 #include <event2/buffer.h> 1764 #include <event2/tag.h> 1765 1766 #if defined(EVENT__HAVE___func__) 1767 # ifndef __func__ 1768 # define __func__ __func__ 1769 # endif 1770 #elif defined(EVENT__HAVE___FUNCTION__) 1771 # define __func__ __FUNCTION__ 1772 #else 1773 # define __func__ __FILE__ 1774 #endif 1775 1776 """ % { 1777 "name": name, 1778 "script_name": _NAME, 1779 "script_version": _VERSION, 1780 } 1781 1782 for statement in CPP_DIRECT: 1783 pre += "%s\n" % statement 1784 1785 pre += '\n#include "%s"\n\n' % header_file 1786 1787 pre += "void event_warn(const char *fmt, ...);\n" 1788 pre += "void event_warnx(const char *fmt, ...);\n\n" 1789 1790 return pre 1791 1792 @staticmethod 1793 def HeaderFilename(filename): 1794 return ".".join(filename.split(".")[:-1]) + ".h" 1795 1796 @staticmethod 1797 def CodeFilename(filename): 1798 return ".".join(filename.split(".")[:-1]) + ".gen.c" 1799 1800 @staticmethod 1801 def Struct(name): 1802 return StructCCode(name) 1803 1804 @staticmethod 1805 def EntryBytes(entry_type, name, tag, fixed_length): 1806 return EntryBytes(entry_type, name, tag, fixed_length) 1807 1808 @staticmethod 1809 def EntryVarBytes(entry_type, name, tag): 1810 return EntryVarBytes(entry_type, name, tag) 1811 1812 @staticmethod 1813 def EntryInt(entry_type, name, tag, bits=32): 1814 return EntryInt(entry_type, name, tag, bits) 1815 1816 @staticmethod 1817 def EntryString(entry_type, name, tag): 1818 return EntryString(entry_type, name, tag) 1819 1820 @staticmethod 1821 def EntryStruct(entry_type, name, tag, struct_name): 1822 return EntryStruct(entry_type, name, tag, struct_name) 1823 1824 @staticmethod 1825 def EntryArray(entry): 1826 return EntryArray(entry) 1827 1828 1829 class CommandLine(object): 1830 def __init__(self, argv=None): 1831 """Initialize a command-line to launch event_rpcgen, as if 1832 from a command-line with CommandLine(sys.argv). If you're 1833 calling this directly, remember to provide a dummy value 1834 for sys.argv[0] 1835 """ 1836 global QUIETLY 1837 1838 self.filename = None 1839 self.header_file = None 1840 self.impl_file = None 1841 self.factory = CCodeGenerator() 1842 1843 parser = argparse.ArgumentParser( 1844 usage="%(prog)s [options] rpc-file [[h-file] c-file]" 1845 ) 1846 parser.add_argument("--quiet", action="store_true", default=False) 1847 parser.add_argument("rpc_file", type=argparse.FileType("r")) 1848 1849 args, extra_args = parser.parse_known_args(args=argv) 1850 1851 QUIETLY = args.quiet 1852 1853 if extra_args: 1854 if len(extra_args) == 1: 1855 self.impl_file = extra_args[0].replace("\\", "/") 1856 elif len(extra_args) == 2: 1857 self.header_file = extra_args[0].replace("\\", "/") 1858 self.impl_file = extra_args[1].replace("\\", "/") 1859 else: 1860 parser.error("Spurious arguments provided") 1861 1862 self.rpc_file = args.rpc_file 1863 1864 if not self.impl_file: 1865 self.impl_file = self.factory.CodeFilename(self.rpc_file.name) 1866 1867 if not self.header_file: 1868 self.header_file = self.factory.HeaderFilename(self.impl_file) 1869 1870 if not self.impl_file.endswith(".c"): 1871 parser.error("can only generate C implementation files") 1872 if not self.header_file.endswith(".h"): 1873 parser.error("can only generate C header files") 1874 1875 def run(self): 1876 filename = self.rpc_file.name 1877 header_file = self.header_file 1878 impl_file = self.impl_file 1879 factory = self.factory 1880 1881 declare('Reading "%s"' % filename) 1882 1883 with self.rpc_file: 1884 entities = Parse(factory, self.rpc_file) 1885 1886 declare('... creating "%s"' % header_file) 1887 with open(header_file, "w") as header_fp: 1888 header_fp.write(factory.HeaderPreamble(filename)) 1889 1890 # Create forward declarations: allows other structs to reference 1891 # each other 1892 for entry in entities: 1893 entry.PrintForwardDeclaration(header_fp) 1894 header_fp.write("\n") 1895 1896 for entry in entities: 1897 entry.PrintTags(header_fp) 1898 entry.PrintDeclaration(header_fp) 1899 header_fp.write(factory.HeaderPostamble(filename)) 1900 1901 declare('... creating "%s"' % impl_file) 1902 with open(impl_file, "w") as impl_fp: 1903 impl_fp.write(factory.BodyPreamble(filename, header_file)) 1904 for entry in entities: 1905 entry.PrintCode(impl_fp) 1906 1907 1908 def main(argv=None): 1909 try: 1910 CommandLine(argv=argv).run() 1911 return 0 1912 except RpcGenError as e: 1913 sys.stderr.write(e) 1914 except EnvironmentError as e: 1915 if e.filename and e.strerror: 1916 sys.stderr.write("%s: %s" % (e.filename, e.strerror)) 1917 elif e.strerror: 1918 sys.stderr.write(e.strerror) 1919 else: 1920 raise 1921 return 1 1922 1923 1924 if __name__ == "__main__": 1925 sys.exit(main(argv=sys.argv[1:]))