diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..444b8db
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+.DS*
+.waf-1*
+.lock*
+**/*.pyc
+build/
+
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..94a9ed0
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/NDNTrafficClient.sample.conf b/NDNTrafficClient.sample.conf
index ea08c50..66c835b 100644
--- a/NDNTrafficClient.sample.conf
+++ b/NDNTrafficClient.sample.conf
@@ -1,59 +1,59 @@
-#
-#THIS IS A SAMPLE CLIENT INTEREST TRAFFIC CONFIGURATION FILE
-#
-# * TO BE USED TO GENERATE INTEREST MESSAGES BASED ON A PROBABILITY
-#   PATTERN.
-# * EVERY INIVIDUAL PATTERN DESCRIPTION MUST BE SEPARATED BY ONE
-#   OR MORE '#' CHARACTERS FOR THE TOOL TO DISTINGUISH THEM
-#   INDIVIUDALLY
-# * THE FOLLOWING PARAMETERS MAY BE ADDED FOR EVERY TRAFFIC PATTERN
-# * (Mandatory) NEXT TO A PARAMETER MEANS EVERY PATTERN SHOULD HAVE
-#   IT FOR BEING CONSIDERED VALID
-#   (Optional) MEANS OTHERWISE
-# * ALSO PROVIDED ARE VALID VALUES POSSIBLE FOR EACH PARAMETER
-# * PLEASE ENSURE THAT THE SUM OF TRAFFIC PERCENTAGE FOR ALL PATTERNS
-#   PROVIDED DOES NOT EXCEED 100 IN ORDER TO MAINTAIN CORRECT BEHAVIOR
-# * NNI STANDS FOR NON-NEGATIVE INTEGER
-# * RANGE OF POSSIBLE VALUES IS SPECIFIED IN [] 
-#
-#
-#(Mandatory)
-#TrafficPercentage=NNI [0-100]
-#Name=NDN Name
-#
-#(Optional)
-#NameAppendBytes=NNI [>0]
-#NameAppendSequenceNumber=NNI [>=0]
-#MinSuffixComponents=NNI
-#MaxSuffixComponents=NNI
-#ExcludeBefore=NDN Name Component
-#ExcludeAfter=NDN Name Component
-#ExcludeBeforeBytes=NNI [>0]
-#ExcludeAfterBytes=NNI [>0]
-#ChildSelector=NNI [0-1]
-#MustBeFresh=NNI [0-1]
-#NonceDuplicationPercentage=NNI [0-100]
-#Scope=NNI
-#InterestLifetime=NNI [Milliseconds]
-#
-#
-##########
-TrafficPercentage=10
-Name=/example
-NameAppendBytes=4
-MinSuffixComponents=2
-##########
-TrafficPercentage=30
-Name=/example/A
-MustBeFresh=1
-NonceDuplicationPercentage=10
-##########
-TrafficPercentage=45
-Name=/example
-ExcludeBeforeBytes=4
-##########
-TrafficPercentage=5
-Name=/example/B
-NameAppendSequenceNumber=1
-Scope=2
-##########
+#
+#THIS IS A SAMPLE CLIENT INTEREST TRAFFIC CONFIGURATION FILE
+#
+# * TO BE USED TO GENERATE INTEREST MESSAGES BASED ON A PROBABILITY
+#   PATTERN.
+# * EVERY INIVIDUAL PATTERN DESCRIPTION MUST BE SEPARATED BY ONE
+#   OR MORE '#' CHARACTERS FOR THE TOOL TO DISTINGUISH THEM
+#   INDIVIUDALLY
+# * THE FOLLOWING PARAMETERS MAY BE ADDED FOR EVERY TRAFFIC PATTERN
+# * (Mandatory) NEXT TO A PARAMETER MEANS EVERY PATTERN SHOULD HAVE
+#   IT FOR BEING CONSIDERED VALID
+#   (Optional) MEANS OTHERWISE
+# * ALSO PROVIDED ARE VALID VALUES POSSIBLE FOR EACH PARAMETER
+# * PLEASE ENSURE THAT THE SUM OF TRAFFIC PERCENTAGE FOR ALL PATTERNS
+#   PROVIDED DOES NOT EXCEED 100 IN ORDER TO MAINTAIN CORRECT BEHAVIOR
+# * NNI STANDS FOR NON-NEGATIVE INTEGER
+# * RANGE OF POSSIBLE VALUES IS SPECIFIED IN [] 
+#
+#
+#(Mandatory)
+#TrafficPercentage=NNI [0-100]
+#Name=NDN Name
+#
+#(Optional)
+#NameAppendBytes=NNI [>0]
+#NameAppendSequenceNumber=NNI [>=0]
+#MinSuffixComponents=NNI
+#MaxSuffixComponents=NNI
+#ExcludeBefore=NDN Name Component
+#ExcludeAfter=NDN Name Component
+#ExcludeBeforeBytes=NNI [>0]
+#ExcludeAfterBytes=NNI [>0]
+#ChildSelector=NNI [0-1]
+#MustBeFresh=NNI [0-1]
+#NonceDuplicationPercentage=NNI [0-100]
+#Scope=NNI
+#InterestLifetime=NNI [Milliseconds]
+#
+#
+##########
+TrafficPercentage=10
+Name=/example
+NameAppendBytes=4
+MinSuffixComponents=2
+##########
+TrafficPercentage=30
+Name=/example/A
+MustBeFresh=1
+NonceDuplicationPercentage=10
+##########
+TrafficPercentage=45
+Name=/example
+ExcludeBeforeBytes=4
+##########
+TrafficPercentage=5
+Name=/example/B
+NameAppendSequenceNumber=1
+Scope=2
+##########
diff --git a/NDNTrafficServer.sample.conf b/NDNTrafficServer.sample.conf
index 40ec726..0e3e4c5 100644
--- a/NDNTrafficServer.sample.conf
+++ b/NDNTrafficServer.sample.conf
@@ -1,38 +1,38 @@
-#
-#THIS IS A SAMPLE SERVER DATA TRAFFIC CONFIGURATION FILE
-#
-# * TO BE USED TO CONFIGURE RESPONSE TO INTERESTS
-# * MULTIPLE SERVER PREFIXES CAN BE CONFIGURED FOR BEING HANDLED
-# * EVERY INIVIDUAL PATTERN DESCRIPTION MUST BE SEPARATED BY ONE
-#   OR MORE '#' CHARACTERS FOR THE TOOL TO DISTINGUISH THEM
-#   INDIVIUDALLY
-# * THE FOLLOWING PARAMETERS MAY BE ADDED FOR EVERY TRAFFIC PATTERN
-# * (Mandatory) NEXT TO A PARAMETER MEANS EVERY PATTERN SHOULD HAVE
-#   IT FOR BEING CONSIDERED VALID
-#   (Optional) MEANS OTHERWISE
-# * ALSO PROVIDED ARE VALID VALUES POSSIBLE FOR EACH PARAMETER
-# * NNI STANDS FOR NON-NEGATIVE INTEGER
-# * RANGE OF POSSIBLE VALUES IS SPECIFIED IN [] 
-#
-#
-#(Mandatory)
-#Name=NDN Name
-#
-#
-#(Optional)
-#ContentType=NNI [>=0]
-#FreshnessPeriod=NNI [Milliseconds]
-#ContentBytes=NNI [>0]
-#Content=String
-#
-#
-##########
-Name=/example/A
-ContentType=1
-ContentBytes=10
-##########
-Name=/example/B
-ContentType=0
-FreshnessPeriod=0
-Content=NoData
-##########
+#
+#THIS IS A SAMPLE SERVER DATA TRAFFIC CONFIGURATION FILE
+#
+# * TO BE USED TO CONFIGURE RESPONSE TO INTERESTS
+# * MULTIPLE SERVER PREFIXES CAN BE CONFIGURED FOR BEING HANDLED
+# * EVERY INIVIDUAL PATTERN DESCRIPTION MUST BE SEPARATED BY ONE
+#   OR MORE '#' CHARACTERS FOR THE TOOL TO DISTINGUISH THEM
+#   INDIVIUDALLY
+# * THE FOLLOWING PARAMETERS MAY BE ADDED FOR EVERY TRAFFIC PATTERN
+# * (Mandatory) NEXT TO A PARAMETER MEANS EVERY PATTERN SHOULD HAVE
+#   IT FOR BEING CONSIDERED VALID
+#   (Optional) MEANS OTHERWISE
+# * ALSO PROVIDED ARE VALID VALUES POSSIBLE FOR EACH PARAMETER
+# * NNI STANDS FOR NON-NEGATIVE INTEGER
+# * RANGE OF POSSIBLE VALUES IS SPECIFIED IN [] 
+#
+#
+#(Mandatory)
+#Name=NDN Name
+#
+#
+#(Optional)
+#ContentType=NNI [>=0]
+#FreshnessPeriod=NNI [Milliseconds]
+#ContentBytes=NNI [>0]
+#Content=String
+#
+#
+##########
+Name=/example/A
+ContentType=1
+ContentBytes=10
+##########
+Name=/example/B
+ContentType=0
+FreshnessPeriod=0
+Content=NoData
+##########
diff --git a/README.md b/README.md
index 7218965..6c66ba2 100644
--- a/README.md
+++ b/README.md
@@ -1,82 +1,82 @@
-Traffic Generator For NDN (ndn-traffic)
-=======================================
-
-This tool is designed to generate interest and data traffic in an NDN network.
-The client and server tool accept traffic configuration files which can be
-used to specify the pattern of NDN traffic that is required to be generated.
-Sample configuration files are provided which include instructions on how 
-to configure various parameters. 
-
-This is an application tool developed over ndn-cpp APIs for TLV packet
-based communication over NDN configured network. The NDN network has to
-be first created with 'ndnx' and 'ndnd-tlv'. This is followed by environment
-security setup with 'ndn-cpp-security-tools'. The application also requires
-installation of ndn-cpp and CPP boost libraries. The installations need to
-follow a strict order as the ndnd
-
-To run the following must be ensured(FOLLOW ORDER STRICTLY)
-
-1. Install ndnx (install all necessary dependencies)
-2. Install CPP Boost Library > 1.47
-
-        sudo apt-get install libboost1.48-all-dev
-
-3. Install ndn-cpp-dev (install all necessary dependencies except boost)
-4. Install ndnd-tlv install all necessary dependencies except boost)
-5. Install and Configure Security Environment with ndn-cpp-security-tools
-
------------------------------------------------------
-
-## 1. Compile And Installation Instructions: ##
-
-    git clone git://github.com/jeraldabraham/ndn-traffic ndn-traffic
-    cd ndn-traffic
-    ./waf configure 
-    ./waf
-    sudo ./waf install
-
-## 2. Tool Run Instructions & Command Line Options: ##
-
-    Usage: ndntrafficserver [options] <Traffic_Configuration_File>
-    Respond to Interest as per provided Traffic Configuration File
-    Multiple Prefixes can be configured for handling.
-    Set environment variable NDN_TRAFFIC_LOGFOLDER for redirecting output to a log.
-      [-d interval] - set delay before responding to interest in milliseconds (minimum 0 milliseconds)
-      [-h] - print help and exit
-
-    Usage: ndntraffic [options] <Traffic_Configuration_File>
-    Generate Interest Traffic as per provided Traffic Configuration File
-    Interests are continuously generated unless a total number is specified.
-    Set environment variable NDN_TRAFFIC_LOGFOLDER for redirecting output to a log.
-      [-i interval] - set interest generation interval in milliseconds (minimum 1000 milliseconds)
-      [-c count] - set total number of interests to be generated
-      [-h] - print help and exit
-
-
-## 3. Sample Run Instructions ##
-
-__ON MACHINE #1__
-
-Start the ndnd-tlv daemon
-
-        ndnd-tlv-start
-
-Start traffic server
-
-        ndntrafficserver NDNTrafficServer.conf
-
-__ON MACHINE #2__
-
-Start the ndnd-tlv daemon
-
-        ndnd-tlv-start
-
-Start the traffic client
-        
-        ndntraffic NDNTrafficClient.conf
-
-
-* These tools need not be used together and can be used individually as well.
-* Please refer sample configuration files provided for details on how to create your own.
-* Use command line options shown above to adjust traffic configuration.
-
+Traffic Generator For NDN (ndn-traffic)
+=======================================
+
+This tool is designed to generate interest and data traffic in an NDN network.
+The client and server tool accept traffic configuration files which can be
+used to specify the pattern of NDN traffic that is required to be generated.
+Sample configuration files are provided which include instructions on how 
+to configure various parameters. 
+
+This is an application tool developed over ndn-cpp APIs for TLV packet
+based communication over NDN configured network. The NDN network has to
+be first created with 'ndnx' and 'ndnd-tlv'. This is followed by environment
+security setup with 'ndn-cpp-security-tools'. The application also requires
+installation of ndn-cpp and CPP boost libraries. The installations need to
+follow a strict order as the ndnd
+
+To run the following must be ensured(FOLLOW ORDER STRICTLY)
+
+1. Install ndnx (install all necessary dependencies)
+2. Install CPP Boost Library > 1.47
+
+        sudo apt-get install libboost1.48-all-dev
+
+3. Install ndn-cpp-dev (install all necessary dependencies except boost)
+4. Install ndnd-tlv install all necessary dependencies except boost)
+5. Install and Configure Security Environment with ndn-cpp-security-tools
+
+-----------------------------------------------------
+
+## 1. Compile And Installation Instructions: ##
+
+    git clone git://github.com/jeraldabraham/ndn-traffic ndn-traffic
+    cd ndn-traffic
+    ./waf configure 
+    ./waf
+    sudo ./waf install
+
+## 2. Tool Run Instructions & Command Line Options: ##
+
+    Usage: ndntrafficserver [options] <Traffic_Configuration_File>
+    Respond to Interest as per provided Traffic Configuration File
+    Multiple Prefixes can be configured for handling.
+    Set environment variable NDN_TRAFFIC_LOGFOLDER for redirecting output to a log.
+      [-d interval] - set delay before responding to interest in milliseconds (minimum 0 milliseconds)
+      [-h] - print help and exit
+
+    Usage: ndntraffic [options] <Traffic_Configuration_File>
+    Generate Interest Traffic as per provided Traffic Configuration File
+    Interests are continuously generated unless a total number is specified.
+    Set environment variable NDN_TRAFFIC_LOGFOLDER for redirecting output to a log.
+      [-i interval] - set interest generation interval in milliseconds (minimum 1000 milliseconds)
+      [-c count] - set total number of interests to be generated
+      [-h] - print help and exit
+
+
+## 3. Sample Run Instructions ##
+
+__ON MACHINE #1__
+
+Start the ndnd-tlv daemon
+
+        ndnd-tlv-start
+
+Start traffic server
+
+        ndntrafficserver NDNTrafficServer.conf
+
+__ON MACHINE #2__
+
+Start the ndnd-tlv daemon
+
+        ndnd-tlv-start
+
+Start the traffic client
+        
+        ndntraffic NDNTrafficClient.conf
+
+
+* These tools need not be used together and can be used individually as well.
+* Please refer sample configuration files provided for details on how to create your own.
+* Use command line options shown above to adjust traffic configuration.
+
diff --git a/logger.hpp b/logger.hpp
new file mode 100644
index 0000000..192f28f
--- /dev/null
+++ b/logger.hpp
@@ -0,0 +1,115 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
+/**
+ * Copyright (C) 2014 University of Arizona.
+ *
+ * GNU 3.0 License, see the LICENSE file for more information
+ *
+ * Author: Jerald Paul Abraham <jeraldabraham@email.arizona.edu>
+ */
+
+#ifndef NTG_LOGGER_HPP
+#define NTG_LOGGER_HPP
+
+#include <string>
+#include <boost/filesystem.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+namespace ndn {
+
+class Logger
+{
+public:
+  Logger(const std::string& module)
+    : m_module(module)
+  {
+  }
+
+  void
+  shutdownLogger()
+  {
+    if (m_logFile.is_open())
+      {
+        log("Terminating Logging Operations" , true, true);
+        m_logFile.close();
+      }
+  }
+
+  static std::string
+  getTimestamp()
+  {
+    boost::posix_time::ptime now;
+    now = boost::posix_time::second_clock::local_time();
+    return to_simple_string(now);
+  }
+
+  void
+  log(const std::string& logLine, bool printTime, bool printToConsole)
+  {
+    if( m_logLocation.length() > 0 )
+      {
+        if (printTime)
+          m_logFile << getTimestamp() << " - ";
+        m_logFile << logLine << std::endl;
+        m_logFile.flush();
+        if (printToConsole)
+          {
+            if (printTime)
+              std::cout << getTimestamp() << " - ";
+            std::cout << logLine << std::endl;
+          }
+      }
+    else
+      {
+        if (printTime)
+          std::cout << getTimestamp() << " - ";
+        std::cout << logLine << std::endl;
+      }
+  }
+
+  void
+  initializeLog(const std::string& instanceId)
+  {
+    char* variableValue = std::getenv("NDN_TRAFFIC_LOGFOLDER");
+    std::string logFilename;
+    m_logLocation = "";
+    if (variableValue != NULL)
+      m_logLocation = variableValue;
+    if (boost::filesystem::exists(boost::filesystem::path(m_logLocation)))
+      {
+        if (boost::filesystem::is_directory(boost::filesystem::path(m_logLocation)))
+          {
+            logFilename = m_logLocation + "/" + m_module + "_" + instanceId + ".log";
+            m_logFile.open(logFilename.c_str(), std::ofstream::out | std::ofstream::trunc);
+            if (m_logFile.is_open())
+              std::cout << "Log File Initialized: " << logFilename << std::endl;
+            else
+              {
+                std::cout << "ERROR - Unable To Initialize A Log File At: " << m_logLocation << std::endl
+                          << "Using Default Output For Logging." << std::endl;
+                m_logLocation = "";
+              }
+          }
+        else
+          {
+            std::cout << "Environment Variable NDN_TRAFFIC_LOGFOLDER Should Be A Folder." << std::endl
+                      << "Using Default Output For Logging." << std::endl;
+            m_logLocation = "";
+          }
+      }
+    else
+      {
+        std::cout << "Environment Variable NDN_TRAFFIC_LOGFOLDER Not Set." << std::endl
+                  << "Using Default Output For Logging." << std::endl;
+        m_logLocation = "";
+      }
+  }
+
+private:
+  std::string m_module;
+  std::string m_logLocation;
+  std::ofstream m_logFile;
+};
+
+} // namespace ndn
+
+#endif // NTG_LOGGER_HPP
diff --git a/ndn-traffic-client.cpp b/ndn-traffic-client.cpp
index 1e159ff..c82b873 100644
--- a/ndn-traffic-client.cpp
+++ b/ndn-traffic-client.cpp
@@ -1,848 +1,762 @@
-/**
- *
- * Copyright (C) 2014 University of Arizona.
- * @author: Jerald Paul Abraham <jeraldabraham@email.arizona.edu>
- *
- */
-
-#include <string>
-#include <sstream>
-#include <fstream>
-#include <vector>
-#include <boost/asio.hpp>
-#include <boost/bind.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-
-#include <ndn-cpp-dev/face.hpp>
-#include <ndn-cpp-dev/exclude.hpp>
-#include <ndn-cpp-dev/name-component.hpp>
-#include <ndn-cpp-dev/security/key-chain.hpp>
-
-using namespace ndn;
-
-class Logger
-{
-public:
-
-  Logger()
-  {
-    logLocation_ = "";
-  }
-
-  void
-  shutdownLogger()
-  {
-    if (logFile_.is_open())
-    {
-      log("Terminating Logging Operations" , true, true);
-      logFile_.close();
-    }
-  }
-
-  static std::string
-  getTimestamp()
-  {
-    boost::posix_time::ptime now;
-    now = boost::posix_time::second_clock::local_time();
-    return to_simple_string(now);
-  }
-
-  void
-  log( std::string logLine, bool printTime, bool printToConsole )
-  {
-    if( logLocation_.length() > 0 )
-    {
-      if (printTime)
-        logFile_ << getTimestamp() << " - ";
-      logFile_ << logLine << std::endl;
-      logFile_.flush();
-      if (printToConsole)
-      {
-        if (printTime)
-          std::cout << getTimestamp() << " - ";
-        std::cout << logLine << std::endl;
-      }
-    }
-    else
-    {
-      if (printTime)
-        std::cout << getTimestamp() << " - ";
-      std::cout << logLine << std::endl;
-    }
-  }
-
-  void
-  initializeLog( std::string instanceId )
-  {
-    char* variableValue = std::getenv("NDN_TRAFFIC_LOGFOLDER");
-    std::string logFilename;
-    logLocation_ = "";
-    if (variableValue != NULL)
-      logLocation_ = variableValue;
-    if (boost::filesystem::exists(boost::filesystem::path(logLocation_)))
-    {
-      if (boost::filesystem::is_directory(boost::filesystem::path(logLocation_)))
-      {
-        logFilename = logLocation_+"/NDNTrafficClient_"+instanceId+".log";
-        logFile_.open(logFilename.c_str(), std::ofstream::out | std::ofstream::trunc);
-        if (logFile_.is_open())
-          std::cout << "Log File Initialized: " << logFilename << std::endl;
-        else
-        {
-          std::cout << "ERROR - Unable To Initialize A Log File At: " << logLocation_ << std::endl
-                    << "Using Default Output For Logging." << std::endl;
-          logLocation_ = "";
-        }
-      }
-      else
-      {
-        std::cout << "Environment Variable NDN_TRAFFIC_LOGFOLDER Should Be A Folder." << std::endl
-                  << "Using Default Output For Logging." << std::endl;
-        logLocation_ = "";
-      }
-    }
-    else
-    {
-      std::cout << "Environment Variable NDN_TRAFFIC_LOGFOLDER Not Set." << std::endl
-                << "Using Default Output For Logging." << std::endl;
-      logLocation_ = "";
-    }
-  }
-
-private:
-
-  std::string logLocation_;
-  std::ofstream logFile_;
-
-};
-
-class NdnTrafficClient
-{
-public:
-
-  NdnTrafficClient( char* programName ) : ioService_(new boost::asio::io_service), face_(ioService_), keyChain_()
-  {
-    std::srand(std::time(0));
-    instanceId_ = toString(std::rand());
-    programName_ = programName;
-    interestInterval_ = getDefaultInterestInterval();
-    interestCount_ = getDefaultInterestCount();
-    configurationFile_ = "";
-    totalInterestSent_ = 0;
-    totalInterestReceived_ = 0;
-    minimumInterestRoundTripTime_ = std::numeric_limits<double>::max();
-    maximumInterestRoundTripTime_ = 0;
-    totalInterestRoundTripTime_ = 0;
-  }
-
-  class InterestTrafficConfiguration
-  {
-  public:
-
-    InterestTrafficConfiguration()
-    {
-      trafficPercentage = -1;
-      name = "";
-      nameAppendBytes = -1;
-      nameAppendSequenceNumber = -1;
-      minSuffixComponents = -1;
-      maxSuffixComponents = -1;
-      excludeBefore = "";
-      excludeAfter = "";
-      excludeBeforeBytes = -1;
-      excludeAfterBytes = -1;
-      childSelector = -1;
-      mustBeFresh = -1;
-      nonceDuplicationPercentage = -1;
-      scope = -1;
-      interestLifetime = -1;
-      totalInterestSent = 0;
-      totalInterestReceived = 0;
-      minimumInterestRoundTripTime = std::numeric_limits<double>::max();
-      maximumInterestRoundTripTime = 0;
-      totalInterestRoundTripTime = 0;
-    }
-
-    void
-    printTrafficConfiguration( Logger& logger )
-    {
-      std::string detail;
-      detail = "";
-      if (trafficPercentage > 0)
-        detail += "TrafficPercentage="+toString(trafficPercentage)+", ";
-      if (name != "")
-        detail += "Name="+name+", ";
-      if (nameAppendBytes > 0)
-        detail += "NameAppendBytes="+toString(nameAppendBytes)+", ";
-      if (nameAppendSequenceNumber > 0)
-        detail += "NameAppendSequenceNumber="+toString(nameAppendSequenceNumber)+", ";
-      if (minSuffixComponents >= 0)
-        detail += "MinSuffixComponents="+toString(minSuffixComponents)+", ";
-      if (maxSuffixComponents >= 0)
-        detail += "MaxSuffixComponents="+toString(maxSuffixComponents)+", ";
-      if (excludeBefore != "")
-        detail += "ExcludeBefore="+excludeBefore+", ";
-      if (excludeAfter != "")
-        detail += "ExcludeAfter="+excludeAfter+", ";
-      if (excludeBeforeBytes > 0)
-        detail += "ExcludeBeforeBytes="+toString(excludeBeforeBytes)+", ";
-      if (excludeAfterBytes > 0)
-        detail += "ExcludeAfterBytes="+toString(excludeAfterBytes)+", ";
-      if (childSelector >= 0)
-        detail += "ChildSelector="+toString(childSelector)+", ";
-      if (mustBeFresh >= 0)
-        detail += "MustBeFresh="+toString(mustBeFresh)+", ";
-      if (nonceDuplicationPercentage > 0)
-        detail += "NonceDuplicationPercentage="+toString(nonceDuplicationPercentage)+", ";
-      if (scope >= 0)
-        detail += "Scope="+toString(scope)+", ";
-      if (interestLifetime >= 0)
-        detail += "InterestLifetime="+toString(interestLifetime)+", ";
-      if (detail.length() >= 0)
-        detail = detail.substr(0, detail.length()-2);
-      logger.log(detail, false, false);
-    }
-
-    bool
-    extractParameterValue( std::string detail, std::string& parameter, std::string& value )
-    {
-      int i;
-      std::string allowedCharacters = ":/+._-%";
-      parameter = "";
-      value = "";
-      i = 0;
-      while (detail[i] != '=' && i < detail.length())
-      {
-        parameter += detail[i];
-        i++;
-      }
-      if (i == detail.length())
-        return false;
-      i++;
-      while ((std::isalnum(detail[i]) || allowedCharacters.find(detail[i]) != std::string::npos) && i < detail.length())
-      {
-        value += detail[i];
-        i++;
-      }
-      if(parameter == "" || value == "")
-        return false;
-      return true;
-    }
-
-    bool
-    processConfigurationDetail( std::string detail, Logger& logger, int lineNumber )
-    {
-      std::string parameter, value;
-      if (extractParameterValue(detail, parameter, value))
-      {
-        if (parameter == "TrafficPercentage")
-          trafficPercentage = toInteger(value);
-        else if (parameter == "Name")
-          name = value;
-        else if (parameter == "NameAppendBytes")
-          nameAppendBytes = toInteger(value);
-        else if (parameter == "NameAppendSequenceNumber")
-          nameAppendSequenceNumber = toInteger(value);
-        else if (parameter == "MinSuffixComponents")
-          minSuffixComponents = toInteger(value);
-        else if (parameter == "MaxSuffixComponents")
-          maxSuffixComponents = toInteger(value);
-        else if (parameter == "ExcludeBefore")
-          excludeBefore = value;
-        else if (parameter == "ExcludeAfter")
-          excludeAfter = value;
-        else if (parameter == "ExcludeBeforeBytes")
-          excludeBeforeBytes = toInteger(value);
-        else if (parameter == "ExcludeAfterBytes")
-          excludeAfterBytes = toInteger(value);
-        else if (parameter == "ChildSelector")
-          childSelector = toInteger(value);
-        else if (parameter == "MustBeFresh")
-          mustBeFresh = toInteger(value);
-        else if (parameter == "NonceDuplicationPercentage")
-          nonceDuplicationPercentage = toInteger(value);
-        else if (parameter == "Scope")
-          scope = toInteger(value);
-        else if (parameter == "InterestLifetime")
-          interestLifetime = toInteger(value);
-        else
-          logger.log("Line "+toString(lineNumber)+" \t- Invalid Parameter='"+parameter+"'", false, true);
-      }
-      else
-      {
-        logger.log("Line "+toString(lineNumber)+" \t- Improper Traffic Configuration Line- "+detail, false, true);
-        return false;
-      }
-      return true;
-    }
-
-    bool
-    checkTrafficDetailCorrectness()
-    {
-      return true;
-    }
-
-    int trafficPercentage;
-    std::string name;
-    int nameAppendBytes;
-    int nameAppendSequenceNumber;
-    int minSuffixComponents;
-    int maxSuffixComponents;
-    std::string excludeBefore;
-    std::string excludeAfter;
-    int excludeBeforeBytes;
-    int excludeAfterBytes;
-    int childSelector;
-    int mustBeFresh;
-    int nonceDuplicationPercentage;
-    int scope;
-    int interestLifetime;
-    int totalInterestSent;
-    int totalInterestReceived;
-    double minimumInterestRoundTripTime;
-    double maximumInterestRoundTripTime;
-    double totalInterestRoundTripTime;
-
-  };
-
-  int
-  getDefaultInterestLifetime()
-  {
-    return 4000;
-  }
-
-  static std::string
-  toString( int integerValue )
-  {
-    std::stringstream stream;
-    stream << integerValue;
-    return stream.str();
-  }
-
-  static std::string
-  toString( double doubleValue )
-  {
-    std::stringstream stream;
-    stream << doubleValue;
-    return stream.str();
-  }
-
-  static int
-  toInteger( std::string stringValue )
-  {
-    int integerValue;
-    std::stringstream stream(stringValue);
-    stream >> integerValue;
-    return integerValue;
-  }
-
-  void
-  usage()
-  {
-
-    std::cout << "\nUsage: " << programName_ << " [options] <Traffic_Configuration_File>\n"
-        "Generate Interest Traffic as per provided Traffic Configuration File\n"
-        "Interests are continuously generated unless a total number is specified.\n"
-        "Set environment variable NDN_TRAFFIC_LOGFOLDER for redirecting output to a log.\n"
-        "  [-i interval] - set interest generation interval in milliseconds (minimum "
-        << getDefaultInterestInterval() << " milliseconds)\n"
-        "  [-c count] - set total number of interests to be generated\n"
-        "  [-h] - print help and exit\n\n";
-    exit(1);
-
-  }
-
-  int
-  getDefaultInterestInterval()
-  {
-    return 1000;
-  }
-
-  int
-  getDefaultInterestCount()
-  {
-    return -1;
-  }
-
-  void
-  setInterestInterval( int interestInterval )
-  {
-    if (interestInterval < 0)
-      usage();
-    interestInterval_ = interestInterval;
-  }
-
-  void
-  setInterestCount( int interestCount )
-  {
-    if (interestCount < 0)
-      usage();
-    interestCount_ = interestCount;
-  }
-
-  void
-  setConfigurationFile( char* configurationFile )
-  {
-    configurationFile_ = configurationFile;
-  }
-
-  void
-  signalHandler()
-  {
-    logger_.shutdownLogger();
-    face_.shutdown();
-    ioService_.reset();
-    logStatistics();
-    exit(1);
-  }
-
-  void
-  logStatistics()
-  {
-    int patternId;
-    double loss, average;
-
-    logger_.log("\n\n== Interest Traffic Report ==\n", false, true);
-    logger_.log("Total Traffic Pattern Types = "+toString((int)trafficPattern_.size()), false, true);
-    logger_.log("Total Interests Sent        = "+toString(totalInterestSent_), false, true);
-    logger_.log("Total Responses Received    = "+toString(totalInterestReceived_), false, true);
-    if (totalInterestSent_ > 0)
-      loss = (totalInterestSent_-totalInterestReceived_)*100.0/totalInterestSent_;
-    else
-      loss = 0;
-    logger_.log("Total Interest Loss         = "+toString(loss)+"%", false, true);
-    if (totalInterestReceived_ > 0)
-      average = totalInterestRoundTripTime_/totalInterestReceived_;
-    else
-      average = 0;
-    logger_.log("Total Round Trip Time       = "+toString(totalInterestRoundTripTime_)+"ms", false, true);
-    logger_.log("Average Round Trip Time     = "+toString(average)+"ms\n", false, true);
-
-    for (patternId=0; patternId<trafficPattern_.size(); patternId++)
-    {
-      logger_.log("Traffic Pattern Type #"+toString(patternId+1), false, true);
-      trafficPattern_[patternId].printTrafficConfiguration(logger_);
-      logger_.log("Total Interests Sent        = "+toString(trafficPattern_[patternId].totalInterestSent), false, true);
-      logger_.log("Total Responses Received    = "+toString(trafficPattern_[patternId].totalInterestReceived), false, true);
-      if (trafficPattern_[patternId].totalInterestSent > 0)
-      {
-        loss = (trafficPattern_[patternId].totalInterestSent-trafficPattern_[patternId].totalInterestReceived);
-        loss *= 100.0;
-        loss /= trafficPattern_[patternId].totalInterestSent;
-      }
-      else
-        loss = 0;
-      logger_.log("Total Interest Loss         = "+toString(loss)+"%", false, true);
-      if (trafficPattern_[patternId].totalInterestReceived > 0)
-        average = trafficPattern_[patternId].totalInterestRoundTripTime/trafficPattern_[patternId].totalInterestReceived;
-      else
-        average = 0;
-      logger_.log("Total Round Trip Time       = "+toString(trafficPattern_[patternId].totalInterestRoundTripTime)+"ms", false, true);
-      logger_.log("Average Round Trip Time     = "+toString(average)+"ms\n", false, true);
-    }
-  }
-
-  bool
-  checkTrafficPatternCorrectness()
-  {
-    return true;
-  }
-
-  void
-  analyzeConfigurationFile()
-  {
-    int patternId;
-    int lineNumber;
-    bool skipLine;
-    std::string patternLine;
-    std::ifstream patternFile;
-    logger_.log("Analyzing Traffic Configuration File: " + configurationFile_, true, true);
-    patternFile.open(configurationFile_.c_str());
-    if (patternFile.is_open())
-    {
-      patternId = 0;
-      lineNumber = 0;
-      while (getline(patternFile, patternLine))
-      {
-        lineNumber++;
-        if (std::isalpha(patternLine[0]))
-        {
-          InterestTrafficConfiguration interestData;
-          skipLine = false;
-          patternId++;
-          if (interestData.processConfigurationDetail(patternLine, logger_, lineNumber))
-          {
-            while (getline(patternFile, patternLine) && std::isalpha(patternLine[0]))
-            {
-              lineNumber++;
-              if (!interestData.processConfigurationDetail(patternLine, logger_, lineNumber))
-              {
-                skipLine = true;
-                break;
-              }
-            }
-            lineNumber++;
-          }
-          else
-            skipLine = true;
-          if( !skipLine )
-          {
-            if (interestData.checkTrafficDetailCorrectness())
-              trafficPattern_.push_back(interestData);
-          }
-        }
-      }
-      patternFile.close();
-      if (!checkTrafficPatternCorrectness())
-      {
-        logger_.log("ERROR - Traffic Configuration Provided Is Not Proper- " + configurationFile_, false, true);
-        logger_.shutdownLogger();
-        exit(1);
-      }
-      logger_.log("Traffic Configuration File Processing Completed\n", true, false);
-      for (patternId=0; patternId<trafficPattern_.size(); patternId++)
-      {
-        logger_.log("Traffic Pattern Type #"+toString(patternId+1), false, false);
-        trafficPattern_[patternId].printTrafficConfiguration(logger_);
-        logger_.log("", false, false);
-      }
-    }
-    else
-    {
-      logger_.log("ERROR - Unable To Open Traffic Configuration File: " + configurationFile_, false, true);
-      logger_.shutdownLogger();
-      exit(1);
-    }
-  }
-
-  void
-  initializeTrafficConfiguration()
-  {
-    if (boost::filesystem::exists(boost::filesystem::path(configurationFile_)))
-    {
-      if(boost::filesystem::is_regular_file(boost::filesystem::path(configurationFile_)))
-      {
-        analyzeConfigurationFile();
-      }
-      else
-      {
-        logger_.log("ERROR - Traffic Configuration File Is Not A Regular File: " + configurationFile_, false, true);
-        logger_.shutdownLogger();
-        exit(1);
-      }
-    }
-    else
-    {
-      logger_.log("ERROR - Traffic Configuration File Does Not Exist: " + configurationFile_, false, true);
-      logger_.shutdownLogger();
-      exit(1);
-    }
-  }
-
-  int
-  getOldNonce()
-  {
-    int randomNonceKey;
-    if (nonceList_.size() == 0)
-      return getNewNonce();
-    std::srand(std::time(0));
-    randomNonceKey = std::rand() % nonceList_.size();
-    return nonceList_[randomNonceKey];
-  }
-
-  int
-  getNewNonce()
-  {
-    int randomNonceKey, i;
-    bool isOld;
-    isOld = true;
-    std::srand(std::time(0));
-    do
-    {
-      randomNonceKey = std::rand();
-      isOld = false;
-      for (i=0; i<nonceList_.size(); i++)
-        if (nonceList_[i] == randomNonceKey)
-          isOld = true;
-    } while(isOld);
-    nonceList_.push_back(randomNonceKey);
-    return randomNonceKey;
-  }
-
-  static std::string
-  getRandomByteString( int randomSize )
-  {
-    int i;
-    std::string characterSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvw0123456789";
-    std::string randomData;
-    for (i=0; i<randomSize; i++)
-      randomData += characterSet[std::rand() % characterSet.length()];
-    return randomData;
-  }
-
-  void
-  onData( ndn::Face &face,
-          const ndn::Interest& interest,
-          ndn::Data& data,
-          int globalReference,
-          int localReference,
-          int patternId,
-          boost::posix_time::ptime sentTime )
-  {
-    double roundTripTime;
-    std::string logLine;
-    logLine = "";
-    logLine += "Data Received      - PatternType="+toString(patternId+1);
-    logLine += ", GlobalID="+toString(globalReference);
-    logLine += ", LocalID="+toString(localReference);
-    logLine += ", Name="+interest.getName().toUri();
-    logger_.log(logLine, true, false);
-    boost::posix_time::time_duration roundTripDuration;
-    totalInterestReceived_++;
-    trafficPattern_[patternId].totalInterestReceived++;
-    roundTripDuration = boost::posix_time::microsec_clock::local_time() - sentTime;
-    roundTripTime = roundTripDuration.total_microseconds()/1000.0;
-    if (minimumInterestRoundTripTime_ > roundTripTime)
-      minimumInterestRoundTripTime_ = roundTripTime;
-    if (maximumInterestRoundTripTime_ < roundTripTime)
-      maximumInterestRoundTripTime_ = roundTripTime;
-    if (trafficPattern_[patternId].minimumInterestRoundTripTime > roundTripTime)
-      trafficPattern_[patternId].minimumInterestRoundTripTime = roundTripTime;
-    if (trafficPattern_[patternId].maximumInterestRoundTripTime < roundTripTime)
-      trafficPattern_[patternId].maximumInterestRoundTripTime = roundTripTime;
-    totalInterestRoundTripTime_ += roundTripTime;
-    trafficPattern_[patternId].totalInterestRoundTripTime += roundTripTime;
-    if (totalInterestSent_ == interestCount_)
-      signalHandler();
-  }
-
-  void
-  onTimeout( ndn::Face &face,
-             const ndn::Interest& interest,
-             int globalReference,
-             int localReference,
-             int patternId)
-  {
-    std::string logLine;
-    logLine = "";
-    logLine += "Interest Timed Out - PatternType="+toString(patternId+1);
-    logLine += ", GlobalID="+toString(globalReference);
-    logLine += ", LocalID="+toString(localReference);
-    logLine += ", Name="+interest.getName().toUri();
-    logger_.log(logLine, true, false);
-    if (totalInterestSent_ == interestCount_)
-      signalHandler();
-  }
-
-  void
-  generateTraffic( const boost::system::error_code& errorCode,
-                   boost::asio::deadline_timer* deadlineTimer )
-  {
-    if ((interestCount_ < 0) || (totalInterestSent_ < interestCount_))
-    {
-      int trafficKey, patternId, cumulativePercentage;
-      std::srand(std::time(0));
-      trafficKey = std::rand() % 100;
-      cumulativePercentage = 0;
-      for (patternId=0; patternId<trafficPattern_.size(); patternId++)
-      {
-        cumulativePercentage += trafficPattern_[patternId].trafficPercentage;
-        if (trafficKey <= cumulativePercentage)
-        {
-          Name interestName(trafficPattern_[patternId].name);
-          if (trafficPattern_[patternId].nameAppendBytes > 0)
-            interestName.append(getRandomByteString(trafficPattern_[patternId].nameAppendBytes));
-          if (trafficPattern_[patternId].nameAppendSequenceNumber >= 0)
-          {
-            interestName.append(toString(trafficPattern_[patternId].nameAppendSequenceNumber));
-            trafficPattern_[patternId].nameAppendSequenceNumber++;
-          }
-          Interest interest(interestName);
-          if (trafficPattern_[patternId].minSuffixComponents >= 0)
-            interest.setMinSuffixComponents(trafficPattern_[patternId].minSuffixComponents);
-          if (trafficPattern_[patternId].maxSuffixComponents >= 0)
-            interest.setMaxSuffixComponents(trafficPattern_[patternId].maxSuffixComponents);
-          Exclude exclude;
-          if (trafficPattern_[patternId].excludeBefore != "" &&  trafficPattern_[patternId].excludeAfter != "")
-          {
-            exclude.excludeRange(name::Component(trafficPattern_[patternId].excludeAfter),
-                                 name::Component(trafficPattern_[patternId].excludeBefore));
-            interest.setExclude(exclude);
-          }
-          else if (trafficPattern_[patternId].excludeBefore != "")
-          {
-            exclude.excludeBefore(name::Component(trafficPattern_[patternId].excludeBefore));
-            interest.setExclude(exclude);
-          }
-          else if (trafficPattern_[patternId].excludeAfter != "")
-          {
-            exclude.excludeAfter(name::Component(trafficPattern_[patternId].excludeAfter));
-            interest.setExclude(exclude);
-          }
-          if (trafficPattern_[patternId].excludeBeforeBytes > 0 &&  trafficPattern_[patternId].excludeAfterBytes > 0)
-          {
-            exclude.excludeRange(name::Component(getRandomByteString(trafficPattern_[patternId].excludeAfterBytes)),
-                                 name::Component(getRandomByteString(trafficPattern_[patternId].excludeBeforeBytes)));
-            interest.setExclude(exclude);
-          }
-          else if (trafficPattern_[patternId].excludeBeforeBytes > 0)
-          {
-            exclude.excludeBefore(name::Component(getRandomByteString(trafficPattern_[patternId].excludeBeforeBytes)));
-            interest.setExclude(exclude);
-          }
-          else if (trafficPattern_[patternId].excludeAfterBytes > 0)
-          {
-            exclude.excludeAfter(name::Component(getRandomByteString(trafficPattern_[patternId].excludeAfterBytes)));
-            interest.setExclude(exclude);
-          }
-
-          if (trafficPattern_[patternId].childSelector >= 0)
-            interest.setChildSelector(trafficPattern_[patternId].childSelector);
-
-          if (trafficPattern_[patternId].mustBeFresh == 0)
-            interest.setMustBeFresh(false);
-          else if (trafficPattern_[patternId].mustBeFresh > 0)
-            interest.setMustBeFresh(true);
-          if (trafficPattern_[patternId].nonceDuplicationPercentage > 0)
-          {
-            int duplicationKey;
-            std::srand(std::time(0));
-            duplicationKey = std::rand() % 100;
-            if (trafficPattern_[patternId].nonceDuplicationPercentage <= duplicationKey)
-              interest.setNonce(getOldNonce());
-            else
-              interest.setNonce(getNewNonce());
-          }
-          else
-            interest.setNonce(getNewNonce());
-          if (trafficPattern_[patternId].scope >= 0)
-            interest.setScope(trafficPattern_[patternId].scope);
-          if (trafficPattern_[patternId].interestLifetime >= 0)
-            interest.setInterestLifetime(trafficPattern_[patternId].interestLifetime);
-          else
-            interest.setInterestLifetime(getDefaultInterestLifetime());
-          try {
-            totalInterestSent_++;
-            trafficPattern_[patternId].totalInterestSent++;
-            boost::posix_time::ptime sentTime;
-            sentTime = boost::posix_time::microsec_clock::local_time();
-            face_.expressInterest(interest,
-                                  func_lib::bind( &NdnTrafficClient::onData,
-                                                  this, boost::ref(face_),
-                                                  _1, _2, totalInterestSent_,
-                                                  trafficPattern_[patternId].totalInterestSent,
-                                                  patternId,
-                                                  sentTime),
-                                  func_lib::bind( &NdnTrafficClient::onTimeout,
-                                                  this, boost::ref(face_),
-                                                  _1, totalInterestSent_,
-                                                  trafficPattern_[patternId].totalInterestSent,
-                                                  patternId));
-            std::string logLine;
-            logLine = "";
-            logLine += "Sending Interest   - PatternType="+toString(patternId+1);
-            logLine += ", GlobalID="+toString(totalInterestSent_);
-            logLine += ", LocalID="+toString(trafficPattern_[patternId].totalInterestSent);
-            logLine += ", Name="+interest.getName().toUri();
-            logger_.log(logLine, true, false);
-            deadlineTimer->expires_at(deadlineTimer->expires_at() +
-                                      boost::posix_time::millisec(interestInterval_));
-            deadlineTimer->async_wait(boost::bind(&NdnTrafficClient::generateTraffic,
-                                                  this,
-                                                  boost::asio::placeholders::error,
-                                                  deadlineTimer));
-          }
-          catch (std::exception &e) {
-            logger_.log("ERROR: "+(std::string)e.what(), true, true);
-          }
-          break;
-        }
-      }
-      if (patternId==trafficPattern_.size())
-      {
-        deadlineTimer->expires_at(deadlineTimer->expires_at() +
-                                  boost::posix_time::millisec(interestInterval_));
-        deadlineTimer->async_wait(boost::bind(&NdnTrafficClient::generateTraffic,
-                                              this,
-                                              boost::asio::placeholders::error,
-                                              deadlineTimer));
-      }
-    }
-  }
-
-  void
-  initialize()
-  {
-    boost::asio::signal_set signalSet(*ioService_, SIGINT, SIGTERM);
-    signalSet.async_wait(boost::bind(&NdnTrafficClient::signalHandler, this));
-    logger_.initializeLog(instanceId_);
-    initializeTrafficConfiguration();
-    boost::asio::deadline_timer deadlineTimer(*ioService_,
-                                              boost::posix_time::millisec(interestInterval_));
-    deadlineTimer.async_wait(boost::bind(&NdnTrafficClient::generateTraffic,
-                                         this,
-                                         boost::asio::placeholders::error,
-                                         &deadlineTimer));
-    try {
-      face_.processEvents();
-    }
-    catch(std::exception &e) {
-      logger_.log("ERROR: "+(std::string)e.what(), true, true);
-      logger_.shutdownLogger();
-    }
-  }
-
-private:
-
-  KeyChain keyChain_;
-  std::string programName_;
-  std::string instanceId_;
-  int interestInterval_;
-  int interestCount_;
-  Logger logger_;
-  std::string configurationFile_;
-  ptr_lib::shared_ptr<boost::asio::io_service> ioService_;
-  Face face_;
-  std::vector<InterestTrafficConfiguration> trafficPattern_;
-  std::vector<int> nonceList_;
-  int totalInterestSent_;
-  int totalInterestReceived_;
-  double minimumInterestRoundTripTime_;
-  double maximumInterestRoundTripTime_;
-  double totalInterestRoundTripTime_;
-
-};
-
-int main( int argc, char* argv[] )
-{
-  int option;
-  NdnTrafficClient ndnTrafficClient (argv[0]);
-  while ((option = getopt(argc, argv, "hi:c:")) != -1) {
-    switch (option) {
-      case 'h'  :
-        ndnTrafficClient.usage();
-        break;
-      case 'i'  :
-        ndnTrafficClient.setInterestInterval(atoi(optarg));
-        break;
-      case 'c'  :
-        ndnTrafficClient.setInterestCount(atoi(optarg));
-        break;
-      default   :
-        ndnTrafficClient.usage();
-        break;
-    }
-  }
-
-  argc -= optind;
-  argv += optind;
-
-  if (argv[0] == NULL)
-    ndnTrafficClient.usage();
-
-  ndnTrafficClient.setConfigurationFile(argv[0]);
-  ndnTrafficClient.initialize();
-
-  return 0;
-}
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
+/**
+ * Copyright (C) 2014 University of Arizona.
+ *
+ * GNU 3.0 License, see the LICENSE file for more information
+ *
+ * Author: Jerald Paul Abraham <jeraldabraham@email.arizona.edu>
+ */
+
+#include <string>
+#include <sstream>
+#include <fstream>
+#include <vector>
+
+#include "logger.hpp"
+
+#include <boost/asio.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+#include <ndn-cpp-dev/face.hpp>
+#include <ndn-cpp-dev/exclude.hpp>
+#include <ndn-cpp-dev/name-component.hpp>
+#include <ndn-cpp-dev/security/key-chain.hpp>
+
+namespace ndn {
+
+class NdnTrafficClient
+{
+public:
+
+  NdnTrafficClient( char* programName )
+    : m_logger("NDNTrafficClient")
+    , ioService_(new boost::asio::io_service)
+    , face_(ioService_)
+    , keyChain_()
+  {
+    std::srand(std::time(0));
+    instanceId_ = toString(std::rand());
+    programName_ = programName;
+    interestInterval_ = getDefaultInterestInterval();
+    interestCount_ = getDefaultInterestCount();
+    configurationFile_ = "";
+    totalInterestSent_ = 0;
+    totalInterestReceived_ = 0;
+    minimumInterestRoundTripTime_ = std::numeric_limits<double>::max();
+    maximumInterestRoundTripTime_ = 0;
+    totalInterestRoundTripTime_ = 0;
+  }
+
+  class InterestTrafficConfiguration
+  {
+  public:
+
+    InterestTrafficConfiguration()
+    {
+      trafficPercentage = -1;
+      name = "";
+      nameAppendBytes = -1;
+      nameAppendSequenceNumber = -1;
+      minSuffixComponents = -1;
+      maxSuffixComponents = -1;
+      excludeBefore = "";
+      excludeAfter = "";
+      excludeBeforeBytes = -1;
+      excludeAfterBytes = -1;
+      childSelector = -1;
+      mustBeFresh = -1;
+      nonceDuplicationPercentage = -1;
+      scope = -1;
+      interestLifetime = -1;
+      totalInterestSent = 0;
+      totalInterestReceived = 0;
+      minimumInterestRoundTripTime = std::numeric_limits<double>::max();
+      maximumInterestRoundTripTime = 0;
+      totalInterestRoundTripTime = 0;
+    }
+
+    void
+    printTrafficConfiguration( Logger& logger )
+    {
+      std::string detail;
+      detail = "";
+      if (trafficPercentage > 0)
+        detail += "TrafficPercentage="+toString(trafficPercentage)+", ";
+      if (name != "")
+        detail += "Name="+name+", ";
+      if (nameAppendBytes > 0)
+        detail += "NameAppendBytes="+toString(nameAppendBytes)+", ";
+      if (nameAppendSequenceNumber > 0)
+        detail += "NameAppendSequenceNumber="+toString(nameAppendSequenceNumber)+", ";
+      if (minSuffixComponents >= 0)
+        detail += "MinSuffixComponents="+toString(minSuffixComponents)+", ";
+      if (maxSuffixComponents >= 0)
+        detail += "MaxSuffixComponents="+toString(maxSuffixComponents)+", ";
+      if (excludeBefore != "")
+        detail += "ExcludeBefore="+excludeBefore+", ";
+      if (excludeAfter != "")
+        detail += "ExcludeAfter="+excludeAfter+", ";
+      if (excludeBeforeBytes > 0)
+        detail += "ExcludeBeforeBytes="+toString(excludeBeforeBytes)+", ";
+      if (excludeAfterBytes > 0)
+        detail += "ExcludeAfterBytes="+toString(excludeAfterBytes)+", ";
+      if (childSelector >= 0)
+        detail += "ChildSelector="+toString(childSelector)+", ";
+      if (mustBeFresh >= 0)
+        detail += "MustBeFresh="+toString(mustBeFresh)+", ";
+      if (nonceDuplicationPercentage > 0)
+        detail += "NonceDuplicationPercentage="+toString(nonceDuplicationPercentage)+", ";
+      if (scope >= 0)
+        detail += "Scope="+toString(scope)+", ";
+      if (interestLifetime >= 0)
+        detail += "InterestLifetime="+toString(interestLifetime)+", ";
+      if (detail.length() >= 2)
+        detail = detail.substr(0, detail.length()-2);
+      logger.log(detail, false, false);
+    }
+
+    bool
+    extractParameterValue( std::string detail, std::string& parameter, std::string& value )
+    {
+      int i;
+      std::string allowedCharacters = ":/+._-%";
+      parameter = "";
+      value = "";
+      i = 0;
+      while (detail[i] != '=' && i < detail.length())
+        {
+          parameter += detail[i];
+          i++;
+        }
+      if (i == detail.length())
+        return false;
+      i++;
+      while ((std::isalnum(detail[i]) || allowedCharacters.find(detail[i]) != std::string::npos) && i < detail.length())
+        {
+          value += detail[i];
+          i++;
+        }
+      if(parameter == "" || value == "")
+        return false;
+      return true;
+    }
+
+    bool
+    processConfigurationDetail( std::string detail, Logger& logger, int lineNumber )
+    {
+      std::string parameter, value;
+      if (extractParameterValue(detail, parameter, value))
+        {
+          if (parameter == "TrafficPercentage")
+            trafficPercentage = toInteger(value);
+          else if (parameter == "Name")
+            name = value;
+          else if (parameter == "NameAppendBytes")
+            nameAppendBytes = toInteger(value);
+          else if (parameter == "NameAppendSequenceNumber")
+            nameAppendSequenceNumber = toInteger(value);
+          else if (parameter == "MinSuffixComponents")
+            minSuffixComponents = toInteger(value);
+          else if (parameter == "MaxSuffixComponents")
+            maxSuffixComponents = toInteger(value);
+          else if (parameter == "ExcludeBefore")
+            excludeBefore = value;
+          else if (parameter == "ExcludeAfter")
+            excludeAfter = value;
+          else if (parameter == "ExcludeBeforeBytes")
+            excludeBeforeBytes = toInteger(value);
+          else if (parameter == "ExcludeAfterBytes")
+            excludeAfterBytes = toInteger(value);
+          else if (parameter == "ChildSelector")
+            childSelector = toInteger(value);
+          else if (parameter == "MustBeFresh")
+            mustBeFresh = toInteger(value);
+          else if (parameter == "NonceDuplicationPercentage")
+            nonceDuplicationPercentage = toInteger(value);
+          else if (parameter == "Scope")
+            scope = toInteger(value);
+          else if (parameter == "InterestLifetime")
+            interestLifetime = toInteger(value);
+          else
+            logger.log("Line "+toString(lineNumber)+" \t- Invalid Parameter='"+parameter+"'", false, true);
+        }
+      else
+        {
+          logger.log("Line "+toString(lineNumber)+" \t- Improper Traffic Configuration Line- "+detail, false, true);
+          return false;
+        }
+      return true;
+    }
+
+    bool
+    checkTrafficDetailCorrectness()
+    {
+      return true;
+    }
+
+    int trafficPercentage;
+    std::string name;
+    int nameAppendBytes;
+    int nameAppendSequenceNumber;
+    int minSuffixComponents;
+    int maxSuffixComponents;
+    std::string excludeBefore;
+    std::string excludeAfter;
+    int excludeBeforeBytes;
+    int excludeAfterBytes;
+    int childSelector;
+    int mustBeFresh;
+    int nonceDuplicationPercentage;
+    int scope;
+    int interestLifetime;
+    int totalInterestSent;
+    int totalInterestReceived;
+    double minimumInterestRoundTripTime;
+    double maximumInterestRoundTripTime;
+    double totalInterestRoundTripTime;
+
+  };
+
+  int
+  getDefaultInterestLifetime()
+  {
+    return 4000;
+  }
+
+  static std::string
+  toString( int integerValue )
+  {
+    std::stringstream stream;
+    stream << integerValue;
+    return stream.str();
+  }
+
+  static std::string
+  toString( double doubleValue )
+  {
+    std::stringstream stream;
+    stream << doubleValue;
+    return stream.str();
+  }
+
+  static int
+  toInteger( std::string stringValue )
+  {
+    int integerValue;
+    std::stringstream stream(stringValue);
+    stream >> integerValue;
+    return integerValue;
+  }
+
+  void
+  usage()
+  {
+
+    std::cout << "\nUsage: " << programName_ << " [options] <Traffic_Configuration_File>\n"
+      "Generate Interest Traffic as per provided Traffic Configuration File\n"
+      "Interests are continuously generated unless a total number is specified.\n"
+      "Set environment variable NDN_TRAFFIC_LOGFOLDER for redirecting output to a log.\n"
+      "  [-i interval] - set interest generation interval in milliseconds (minimum "
+              << getDefaultInterestInterval() << " milliseconds)\n"
+      "  [-c count] - set total number of interests to be generated\n"
+      "  [-h] - print help and exit\n\n";
+    exit(1);
+
+  }
+
+  int
+  getDefaultInterestInterval()
+  {
+    return 1000;
+  }
+
+  int
+  getDefaultInterestCount()
+  {
+    return -1;
+  }
+
+  void
+  setInterestInterval( int interestInterval )
+  {
+    if (interestInterval < 0)
+      usage();
+    interestInterval_ = interestInterval;
+  }
+
+  void
+  setInterestCount( int interestCount )
+  {
+    if (interestCount < 0)
+      usage();
+    interestCount_ = interestCount;
+  }
+
+  void
+  setConfigurationFile( char* configurationFile )
+  {
+    configurationFile_ = configurationFile;
+  }
+
+  void
+  signalHandler()
+  {
+    m_logger.shutdownLogger();
+    face_.shutdown();
+    ioService_.reset();
+    logStatistics();
+    exit(1);
+  }
+
+  void
+  logStatistics()
+  {
+    int patternId;
+    double loss, average;
+
+    m_logger.log("\n\n== Interest Traffic Report ==\n", false, true);
+    m_logger.log("Total Traffic Pattern Types = "+toString((int)trafficPattern_.size()), false, true);
+    m_logger.log("Total Interests Sent        = "+toString(totalInterestSent_), false, true);
+    m_logger.log("Total Responses Received    = "+toString(totalInterestReceived_), false, true);
+    if (totalInterestSent_ > 0)
+      loss = (totalInterestSent_-totalInterestReceived_)*100.0/totalInterestSent_;
+    else
+      loss = 0;
+    m_logger.log("Total Interest Loss         = "+toString(loss)+"%", false, true);
+    if (totalInterestReceived_ > 0)
+      average = totalInterestRoundTripTime_/totalInterestReceived_;
+    else
+      average = 0;
+    m_logger.log("Total Round Trip Time       = "+toString(totalInterestRoundTripTime_)+"ms", false, true);
+    m_logger.log("Average Round Trip Time     = "+toString(average)+"ms\n", false, true);
+
+    for (patternId=0; patternId<trafficPattern_.size(); patternId++)
+      {
+        m_logger.log("Traffic Pattern Type #"+toString(patternId+1), false, true);
+        trafficPattern_[patternId].printTrafficConfiguration(m_logger);
+        m_logger.log("Total Interests Sent        = "+toString(trafficPattern_[patternId].totalInterestSent), false, true);
+        m_logger.log("Total Responses Received    = "+toString(trafficPattern_[patternId].totalInterestReceived), false, true);
+        if (trafficPattern_[patternId].totalInterestSent > 0)
+          {
+            loss = (trafficPattern_[patternId].totalInterestSent-trafficPattern_[patternId].totalInterestReceived);
+            loss *= 100.0;
+            loss /= trafficPattern_[patternId].totalInterestSent;
+          }
+        else
+          loss = 0;
+        m_logger.log("Total Interest Loss         = "+toString(loss)+"%", false, true);
+        if (trafficPattern_[patternId].totalInterestReceived > 0)
+          average = trafficPattern_[patternId].totalInterestRoundTripTime/trafficPattern_[patternId].totalInterestReceived;
+        else
+          average = 0;
+        m_logger.log("Total Round Trip Time       = "+toString(trafficPattern_[patternId].totalInterestRoundTripTime)+"ms", false, true);
+        m_logger.log("Average Round Trip Time     = "+toString(average)+"ms\n", false, true);
+      }
+  }
+
+  bool
+  checkTrafficPatternCorrectness()
+  {
+    return true;
+  }
+
+  void
+  analyzeConfigurationFile()
+  {
+    int patternId;
+    int lineNumber;
+    bool skipLine;
+    std::string patternLine;
+    std::ifstream patternFile;
+    m_logger.log("Analyzing Traffic Configuration File: " + configurationFile_, true, true);
+    patternFile.open(configurationFile_.c_str());
+    if (patternFile.is_open())
+      {
+        patternId = 0;
+        lineNumber = 0;
+        while (getline(patternFile, patternLine))
+          {
+            lineNumber++;
+            if (std::isalpha(patternLine[0]))
+              {
+                InterestTrafficConfiguration interestData;
+                skipLine = false;
+                patternId++;
+                if (interestData.processConfigurationDetail(patternLine, m_logger, lineNumber))
+                  {
+                    while (getline(patternFile, patternLine) && std::isalpha(patternLine[0]))
+                      {
+                        lineNumber++;
+                        if (!interestData.processConfigurationDetail(patternLine, m_logger, lineNumber))
+                          {
+                            skipLine = true;
+                            break;
+                          }
+                      }
+                    lineNumber++;
+                  }
+                else
+                  skipLine = true;
+                if( !skipLine )
+                  {
+                    if (interestData.checkTrafficDetailCorrectness())
+                      trafficPattern_.push_back(interestData);
+                  }
+              }
+          }
+        patternFile.close();
+        if (!checkTrafficPatternCorrectness())
+          {
+            m_logger.log("ERROR - Traffic Configuration Provided Is Not Proper- " + configurationFile_, false, true);
+            m_logger.shutdownLogger();
+            exit(1);
+          }
+        m_logger.log("Traffic Configuration File Processing Completed\n", true, false);
+        for (patternId=0; patternId<trafficPattern_.size(); patternId++)
+          {
+            m_logger.log("Traffic Pattern Type #"+toString(patternId+1), false, false);
+            trafficPattern_[patternId].printTrafficConfiguration(m_logger);
+            m_logger.log("", false, false);
+          }
+      }
+    else
+      {
+        m_logger.log("ERROR - Unable To Open Traffic Configuration File: " + configurationFile_, false, true);
+        m_logger.shutdownLogger();
+        exit(1);
+      }
+  }
+
+  void
+  initializeTrafficConfiguration()
+  {
+    if (boost::filesystem::exists(boost::filesystem::path(configurationFile_)))
+      {
+        if(boost::filesystem::is_regular_file(boost::filesystem::path(configurationFile_)))
+          {
+            analyzeConfigurationFile();
+          }
+        else
+          {
+            m_logger.log("ERROR - Traffic Configuration File Is Not A Regular File: " + configurationFile_, false, true);
+            m_logger.shutdownLogger();
+            exit(1);
+          }
+      }
+    else
+      {
+        m_logger.log("ERROR - Traffic Configuration File Does Not Exist: " + configurationFile_, false, true);
+        m_logger.shutdownLogger();
+        exit(1);
+      }
+  }
+
+  int
+  getOldNonce()
+  {
+    int randomNonceKey;
+    if (nonceList_.size() == 0)
+      return getNewNonce();
+    std::srand(std::time(0));
+    randomNonceKey = std::rand() % nonceList_.size();
+    return nonceList_[randomNonceKey];
+  }
+
+  int
+  getNewNonce()
+  {
+    int randomNonceKey, i;
+    bool isOld;
+    isOld = true;
+    std::srand(std::time(0));
+    do
+      {
+        randomNonceKey = std::rand();
+        isOld = false;
+        for (i=0; i<nonceList_.size(); i++)
+          if (nonceList_[i] == randomNonceKey)
+            isOld = true;
+      } while(isOld);
+    nonceList_.push_back(randomNonceKey);
+    return randomNonceKey;
+  }
+
+  static std::string
+  getRandomByteString( int randomSize )
+  {
+    int i;
+    std::string characterSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvw0123456789";
+    std::string randomData;
+    for (i=0; i<randomSize; i++)
+      randomData += characterSet[std::rand() % characterSet.length()];
+    return randomData;
+  }
+
+  void
+  onData( ndn::Face &face,
+          const ndn::Interest& interest,
+          ndn::Data& data,
+          int globalReference,
+          int localReference,
+          int patternId,
+          boost::posix_time::ptime sentTime )
+  {
+    double roundTripTime;
+    std::string logLine;
+    logLine = "";
+    logLine += "Data Received      - PatternType="+toString(patternId+1);
+    logLine += ", GlobalID="+toString(globalReference);
+    logLine += ", LocalID="+toString(localReference);
+    logLine += ", Name="+interest.getName().toUri();
+    m_logger.log(logLine, true, false);
+    boost::posix_time::time_duration roundTripDuration;
+    totalInterestReceived_++;
+    trafficPattern_[patternId].totalInterestReceived++;
+    roundTripDuration = boost::posix_time::microsec_clock::local_time() - sentTime;
+    roundTripTime = roundTripDuration.total_microseconds()/1000.0;
+    if (minimumInterestRoundTripTime_ > roundTripTime)
+      minimumInterestRoundTripTime_ = roundTripTime;
+    if (maximumInterestRoundTripTime_ < roundTripTime)
+      maximumInterestRoundTripTime_ = roundTripTime;
+    if (trafficPattern_[patternId].minimumInterestRoundTripTime > roundTripTime)
+      trafficPattern_[patternId].minimumInterestRoundTripTime = roundTripTime;
+    if (trafficPattern_[patternId].maximumInterestRoundTripTime < roundTripTime)
+      trafficPattern_[patternId].maximumInterestRoundTripTime = roundTripTime;
+    totalInterestRoundTripTime_ += roundTripTime;
+    trafficPattern_[patternId].totalInterestRoundTripTime += roundTripTime;
+    if (totalInterestSent_ == interestCount_)
+      signalHandler();
+  }
+
+  void
+  onTimeout( ndn::Face &face,
+             const ndn::Interest& interest,
+             int globalReference,
+             int localReference,
+             int patternId)
+  {
+    std::string logLine;
+    logLine = "";
+    logLine += "Interest Timed Out - PatternType="+toString(patternId+1);
+    logLine += ", GlobalID="+toString(globalReference);
+    logLine += ", LocalID="+toString(localReference);
+    logLine += ", Name="+interest.getName().toUri();
+    m_logger.log(logLine, true, false);
+    if (totalInterestSent_ == interestCount_)
+      signalHandler();
+  }
+
+  void
+  generateTraffic( const boost::system::error_code& errorCode,
+                   boost::asio::deadline_timer* deadlineTimer )
+  {
+    if ((interestCount_ < 0) || (totalInterestSent_ < interestCount_))
+      {
+        int trafficKey, patternId, cumulativePercentage;
+        std::srand(std::time(0));
+        trafficKey = std::rand() % 100;
+        cumulativePercentage = 0;
+        for (patternId=0; patternId<trafficPattern_.size(); patternId++)
+          {
+            cumulativePercentage += trafficPattern_[patternId].trafficPercentage;
+            if (trafficKey <= cumulativePercentage)
+              {
+                Name interestName(trafficPattern_[patternId].name);
+                if (trafficPattern_[patternId].nameAppendBytes > 0)
+                  interestName.append(getRandomByteString(trafficPattern_[patternId].nameAppendBytes));
+                if (trafficPattern_[patternId].nameAppendSequenceNumber >= 0)
+                  {
+                    interestName.append(toString(trafficPattern_[patternId].nameAppendSequenceNumber));
+                    trafficPattern_[patternId].nameAppendSequenceNumber++;
+                  }
+                Interest interest(interestName);
+                if (trafficPattern_[patternId].minSuffixComponents >= 0)
+                  interest.setMinSuffixComponents(trafficPattern_[patternId].minSuffixComponents);
+                if (trafficPattern_[patternId].maxSuffixComponents >= 0)
+                  interest.setMaxSuffixComponents(trafficPattern_[patternId].maxSuffixComponents);
+                Exclude exclude;
+                if (trafficPattern_[patternId].excludeBefore != "" &&  trafficPattern_[patternId].excludeAfter != "")
+                  {
+                    exclude.excludeRange(name::Component(trafficPattern_[patternId].excludeAfter),
+                                         name::Component(trafficPattern_[patternId].excludeBefore));
+                    interest.setExclude(exclude);
+                  }
+                else if (trafficPattern_[patternId].excludeBefore != "")
+                  {
+                    exclude.excludeBefore(name::Component(trafficPattern_[patternId].excludeBefore));
+                    interest.setExclude(exclude);
+                  }
+                else if (trafficPattern_[patternId].excludeAfter != "")
+                  {
+                    exclude.excludeAfter(name::Component(trafficPattern_[patternId].excludeAfter));
+                    interest.setExclude(exclude);
+                  }
+                if (trafficPattern_[patternId].excludeBeforeBytes > 0 &&  trafficPattern_[patternId].excludeAfterBytes > 0)
+                  {
+                    exclude.excludeRange(name::Component(getRandomByteString(trafficPattern_[patternId].excludeAfterBytes)),
+                                         name::Component(getRandomByteString(trafficPattern_[patternId].excludeBeforeBytes)));
+                    interest.setExclude(exclude);
+                  }
+                else if (trafficPattern_[patternId].excludeBeforeBytes > 0)
+                  {
+                    exclude.excludeBefore(name::Component(getRandomByteString(trafficPattern_[patternId].excludeBeforeBytes)));
+                    interest.setExclude(exclude);
+                  }
+                else if (trafficPattern_[patternId].excludeAfterBytes > 0)
+                  {
+                    exclude.excludeAfter(name::Component(getRandomByteString(trafficPattern_[patternId].excludeAfterBytes)));
+                    interest.setExclude(exclude);
+                  }
+
+                if (trafficPattern_[patternId].childSelector >= 0)
+                  interest.setChildSelector(trafficPattern_[patternId].childSelector);
+
+                if (trafficPattern_[patternId].mustBeFresh == 0)
+                  interest.setMustBeFresh(false);
+                else if (trafficPattern_[patternId].mustBeFresh > 0)
+                  interest.setMustBeFresh(true);
+                if (trafficPattern_[patternId].nonceDuplicationPercentage > 0)
+                  {
+                    int duplicationKey;
+                    std::srand(std::time(0));
+                    duplicationKey = std::rand() % 100;
+                    if (trafficPattern_[patternId].nonceDuplicationPercentage <= duplicationKey)
+                      interest.setNonce(getOldNonce());
+                    else
+                      interest.setNonce(getNewNonce());
+                  }
+                else
+                  interest.setNonce(getNewNonce());
+                if (trafficPattern_[patternId].scope >= 0)
+                  interest.setScope(trafficPattern_[patternId].scope);
+                if (trafficPattern_[patternId].interestLifetime >= 0)
+                  interest.setInterestLifetime(trafficPattern_[patternId].interestLifetime);
+                else
+                  interest.setInterestLifetime(getDefaultInterestLifetime());
+                try {
+                  totalInterestSent_++;
+                  trafficPattern_[patternId].totalInterestSent++;
+                  boost::posix_time::ptime sentTime;
+                  sentTime = boost::posix_time::microsec_clock::local_time();
+                  face_.expressInterest(interest,
+                                        func_lib::bind( &NdnTrafficClient::onData,
+                                                        this, boost::ref(face_),
+                                                        _1, _2, totalInterestSent_,
+                                                        trafficPattern_[patternId].totalInterestSent,
+                                                        patternId,
+                                                        sentTime),
+                                        func_lib::bind( &NdnTrafficClient::onTimeout,
+                                                        this, boost::ref(face_),
+                                                        _1, totalInterestSent_,
+                                                        trafficPattern_[patternId].totalInterestSent,
+                                                        patternId));
+                  std::string logLine;
+                  logLine = "";
+                  logLine += "Sending Interest   - PatternType="+toString(patternId+1);
+                  logLine += ", GlobalID="+toString(totalInterestSent_);
+                  logLine += ", LocalID="+toString(trafficPattern_[patternId].totalInterestSent);
+                  logLine += ", Name="+interest.getName().toUri();
+                  m_logger.log(logLine, true, false);
+                  deadlineTimer->expires_at(deadlineTimer->expires_at() +
+                                            boost::posix_time::millisec(interestInterval_));
+                  deadlineTimer->async_wait(boost::bind(&NdnTrafficClient::generateTraffic,
+                                                        this,
+                                                        boost::asio::placeholders::error,
+                                                        deadlineTimer));
+                }
+                catch (std::exception &e) {
+                  m_logger.log("ERROR: "+(std::string)e.what(), true, true);
+                }
+                break;
+              }
+          }
+        if (patternId==trafficPattern_.size())
+          {
+            deadlineTimer->expires_at(deadlineTimer->expires_at() +
+                                      boost::posix_time::millisec(interestInterval_));
+            deadlineTimer->async_wait(boost::bind(&NdnTrafficClient::generateTraffic,
+                                                  this,
+                                                  boost::asio::placeholders::error,
+                                                  deadlineTimer));
+          }
+      }
+  }
+
+  void
+  initialize()
+  {
+    boost::asio::signal_set signalSet(*ioService_, SIGINT, SIGTERM);
+    signalSet.async_wait(boost::bind(&NdnTrafficClient::signalHandler, this));
+    m_logger.initializeLog(instanceId_);
+    initializeTrafficConfiguration();
+    boost::asio::deadline_timer deadlineTimer(*ioService_,
+                                              boost::posix_time::millisec(interestInterval_));
+    deadlineTimer.async_wait(boost::bind(&NdnTrafficClient::generateTraffic,
+                                         this,
+                                         boost::asio::placeholders::error,
+                                         &deadlineTimer));
+    try {
+      face_.processEvents();
+    }
+    catch(std::exception &e) {
+      m_logger.log("ERROR: "+(std::string)e.what(), true, true);
+      m_logger.shutdownLogger();
+    }
+  }
+
+private:
+
+  KeyChain keyChain_;
+  std::string programName_;
+  std::string instanceId_;
+  int interestInterval_;
+  int interestCount_;
+  Logger m_logger;
+  std::string configurationFile_;
+  ptr_lib::shared_ptr<boost::asio::io_service> ioService_;
+  Face face_;
+  std::vector<InterestTrafficConfiguration> trafficPattern_;
+  std::vector<int> nonceList_;
+  int totalInterestSent_;
+  int totalInterestReceived_;
+  double minimumInterestRoundTripTime_;
+  double maximumInterestRoundTripTime_;
+  double totalInterestRoundTripTime_;
+
+};
+
+} // namespace ndn
+
+int main( int argc, char* argv[] )
+{
+  int option;
+  ndn::NdnTrafficClient ndnTrafficClient (argv[0]);
+  while ((option = getopt(argc, argv, "hi:c:")) != -1) {
+    switch (option) {
+    case 'h'  :
+      ndnTrafficClient.usage();
+      break;
+    case 'i'  :
+      ndnTrafficClient.setInterestInterval(atoi(optarg));
+      break;
+    case 'c'  :
+      ndnTrafficClient.setInterestCount(atoi(optarg));
+      break;
+    default   :
+      ndnTrafficClient.usage();
+      break;
+    }
+  }
+
+  argc -= optind;
+  argv += optind;
+
+  if (argv[0] == NULL)
+    ndnTrafficClient.usage();
+
+  ndnTrafficClient.setConfigurationFile(argv[0]);
+  ndnTrafficClient.initialize();
+
+  return 0;
+}
diff --git a/ndn-traffic-server.cpp b/ndn-traffic-server.cpp
index 38b3461..0e64a39 100644
--- a/ndn-traffic-server.cpp
+++ b/ndn-traffic-server.cpp
@@ -1,538 +1,451 @@
-/**
- *
- * Copyright (C) 2014 University of Arizona.
- * @author: Jerald Paul Abraham <jeraldabraham@email.arizona.edu>
- *
- */
-
-#include <sstream>
-#include <boost/asio.hpp>
-#include <boost/filesystem.hpp>
-
-#include <ndn-cpp-dev/face.hpp>
-#include <ndn-cpp-dev/security/key-chain.hpp>
-
-using namespace ndn;
-
-class Logger
-{
-public:
-
-  Logger()
-  {
-    logLocation_ = "";
-  }
-
-  void
-  shutdownLogger()
-  {
-    if (logFile_.is_open())
-    {
-      log("Terminating Logging Operations" , true, true);
-      logFile_.close();
-    }
-  }
-
-  static std::string
-  getTimestamp()
-  {
-    boost::posix_time::ptime now;
-    now = boost::posix_time::second_clock::local_time();
-    return to_simple_string(now);
-  }
-
-  void
-  log( std::string logLine, bool printTime, bool printToConsole )
-  {
-    if( logLocation_.length() > 0 )
-    {
-      if (printTime)
-        logFile_ << getTimestamp() << " - ";
-      logFile_ << logLine << std::endl;
-      logFile_.flush();
-      if (printToConsole)
-      {
-        if (printTime)
-          std::cout << getTimestamp() << " - ";
-        std::cout << logLine << std::endl;
-      }
-    }
-    else
-    {
-      if (printTime)
-        std::cout << getTimestamp() << " - ";
-      std::cout << logLine << std::endl;
-    }
-  }
-
-  void
-  initializeLog( std::string instanceId )
-  {
-    char* variableValue = std::getenv("NDN_TRAFFIC_LOGFOLDER");
-    std::string logFilename;
-    logLocation_ = "";
-    if (variableValue != NULL)
-      logLocation_ = variableValue;
-    if (boost::filesystem::exists(boost::filesystem::path(logLocation_)))
-    {
-      if (boost::filesystem::is_directory(boost::filesystem::path(logLocation_)))
-      {
-        logFilename = logLocation_+"/NDNTrafficServer_"+instanceId+".log";
-        logFile_.open(logFilename.c_str(), std::ofstream::out | std::ofstream::trunc);
-        if (logFile_.is_open())
-          std::cout << "Log File Initialized: " << logFilename << std::endl;
-        else
-        {
-          std::cout << "ERROR - Unable To Initialize A Log File At: " << logLocation_ << std::endl
-                    << "Using Default Output For Logging." << std::endl;
-          logLocation_ = "";
-        }
-      }
-      else
-      {
-        std::cout << "Environment Variable NDN_TRAFFIC_LOGFOLDER Should Be A Folder." << std::endl
-                  << "Using Default Output For Logging." << std::endl;
-        logLocation_ = "";
-      }
-    }
-    else
-    {
-      std::cout << "Environment Variable NDN_TRAFFIC_LOGFOLDER Not Set." << std::endl
-                << "Using Default Output For Logging." << std::endl;
-      logLocation_ = "";
-    }
-  }
-
-private:
-
-  std::string logLocation_;
-  std::ofstream logFile_;
-
-};
-
-
-class NdnTrafficServer
-{
-public:
-
-  NdnTrafficServer( char* programName ) : ioService_(new boost::asio::io_service), face_(ioService_), keyChain_()
-  {
-    std::srand(std::time(0));
-    instanceId_ = toString(std::rand());
-    programName_ = programName;
-    contentDelayTime_ = getDefaultContentDelayTime();
-    totalRegistrationsFailed_ = 0;
-    configurationFile_ = "";
-    totalInterestReceived_ = 0;
-  }
-
-  class DataTrafficConfiguration
-  {
-  public:
-
-    DataTrafficConfiguration()
-    {
-      name = "";
-      contentType = -1;
-      freshnessPeriod = -1;
-      contentBytes = -1;
-      content = "";
-      totalInterestReceived = 0;
-    }
-
-    void
-    printTrafficConfiguration( Logger& logger )
-    {
-      std::string detail;
-      detail = "";
-      if (name != "")
-        detail += "Name="+name+", ";
-      if (contentType >= 0)
-        detail += "ContentType="+toString(contentType)+", ";
-      if (freshnessPeriod >= 0)
-        detail += "FreshnessPeriod="+toString(freshnessPeriod)+", ";
-      if (contentBytes >= 0)
-        detail += "ContentBytes="+toString(contentBytes)+", ";
-      if (content != "")
-        detail += "Content="+content+", ";
-      if (detail.length() >= 0)
-        detail = detail.substr(0, detail.length()-2);
-      logger.log(detail, false, false);
-    }
-
-
-    bool
-    extractParameterValue( std::string detail, std::string& parameter, std::string& value )
-    {
-      int i;
-      std::string allowedCharacters = ":/+._-%";
-      parameter = "";
-      value = "";
-      i = 0;
-      while (detail[i] != '=' && i < detail.length())
-      {
-        parameter += detail[i];
-        i++;
-      }
-      if (i == detail.length())
-        return false;
-      i++;
-      while ((std::isalnum(detail[i]) || allowedCharacters.find(detail[i]) != std::string::npos) && i < detail.length())
-      {
-        value += detail[i];
-        i++;
-      }
-      if(parameter == "" || value == "")
-        return false;
-      return true;
-    }
-
-    bool
-    processConfigurationDetail( std::string detail, Logger& logger, int lineNumber )
-    {
-      std::string parameter, value;
-      if (extractParameterValue(detail, parameter, value))
-      {
-        if (parameter == "Name")
-          name = value;
-        else if (parameter == "ContentType")
-          contentType = toInteger(value);
-        else if (parameter == "FreshnessPeriod")
-          freshnessPeriod = toInteger(value);
-        else if (parameter == "ContentBytes")
-          contentBytes = toInteger(value);
-        else if (parameter == "Content")
-          content = value;
-        else
-          logger.log("Line "+toString(lineNumber)+" \t- Invalid Parameter='"+parameter+"'", false, true);
-      }
-      else
-      {
-        logger.log("Line "+toString(lineNumber)+" \t- Improper Traffic Configuration Line- "+detail, false, true);
-        return false;
-      }
-      return true;
-    }
-
-    bool
-    checkTrafficDetailCorrectness()
-    {
-      return true;
-    }
-
-    std::string name;
-    int contentType;
-    int freshnessPeriod;
-    int contentBytes;
-    std::string content;
-    int totalInterestReceived;
-
-  };
-
-  std::string
-  getDefaultContent()
-  {
-    return "";
-  }
-
-  static std::string
-  toString( int integerValue )
-  {
-    std::stringstream stream;
-    stream << integerValue;
-    return stream.str();
-  }
-
-  static int
-  toInteger( std::string stringValue )
-  {
-    int integerValue;
-    std::stringstream stream(stringValue);
-    stream >> integerValue;
-    return integerValue;
-  }
-
-  void
-  usage()
-  {
-
-    std::cout << "\nUsage: " << programName_ << " [options] <Traffic_Configuration_File>\n"
-        "Respond to Interest as per provided Traffic Configuration File\n"
-        "Multiple Prefixes can be configured for handling.\n"
-        "Set environment variable NDN_TRAFFIC_LOGFOLDER for redirecting output to a log.\n"
-        "  [-d interval] - set delay before responding to interest in milliseconds (minimum "
-        << getDefaultContentDelayTime() << " milliseconds)\n"
-        "  [-h] - print help and exit\n\n";
-    exit(1);
-
-  }
-
-  int
-  getDefaultContentDelayTime()
-  {
-    return 0;
-  }
-
-  void
-  setContentDelayTime( int contentDelayTime )
-  {
-    if (contentDelayTime < 0)
-      usage();
-    contentDelayTime_ = contentDelayTime;
-  }
-
-  void
-  setConfigurationFile( char* configurationFile )
-  {
-    configurationFile_ = configurationFile;
-  }
-
-  void
-  signalHandler()
-  {
-    logger_.shutdownLogger();
-    face_.shutdown();
-    ioService_.reset();
-    logStatistics();
-    exit(1);
-  }
-
-  void
-  logStatistics()
-  {
-    int patternId;
-    logger_.log("\n\n== Interest Traffic Report ==\n", false, true);
-    logger_.log("Total Traffic Pattern Types = "+toString((int)trafficPattern_.size()), false, true);
-    logger_.log("Total Interests Received    = "+toString(totalInterestReceived_), false, true);
-    for (patternId=0; patternId<trafficPattern_.size(); patternId++)
-    {
-      logger_.log("\nTraffic Pattern Type #"+toString(patternId+1), false, true);
-      trafficPattern_[patternId].printTrafficConfiguration(logger_);
-      logger_.log("Total Interests Received    = "+toString(trafficPattern_[patternId].totalInterestReceived)+"\n", false, true);
-    }
-  }
-
-  bool
-  checkTrafficPatternCorrectness()
-  {
-    return true;
-  }
-
-  void
-  analyzeConfigurationFile()
-  {
-    int patternId;
-    int lineNumber;
-    bool skipLine;
-    std::string patternLine;
-    std::ifstream patternFile;
-    logger_.log("Analyzing Traffic Configuration File: " + configurationFile_, true, true);
-    patternFile.open(configurationFile_.c_str());
-    if (patternFile.is_open())
-    {
-      patternId = 0;
-      lineNumber = 0;
-      while (getline(patternFile, patternLine))
-      {
-        lineNumber++;
-        if (std::isalpha(patternLine[0]))
-        {
-          DataTrafficConfiguration dataData;
-          skipLine = false;
-          patternId++;
-          if (dataData.processConfigurationDetail(patternLine, logger_, lineNumber))
-          {
-            while (getline(patternFile, patternLine) && std::isalpha(patternLine[0]))
-            {
-              lineNumber++;
-              if (!dataData.processConfigurationDetail(patternLine, logger_, lineNumber))
-              {
-                skipLine = true;
-                break;
-              }
-            }
-            lineNumber++;
-          }
-          else
-            skipLine = true;
-          if( !skipLine )
-          {
-            if (dataData.checkTrafficDetailCorrectness())
-              trafficPattern_.push_back(dataData);
-          }
-        }
-      }
-      patternFile.close();
-      if (!checkTrafficPatternCorrectness())
-      {
-        logger_.log("ERROR - Traffic Configuration Provided Is Not Proper- " + configurationFile_, false, true);
-        logger_.shutdownLogger();
-        exit(1);
-      }
-      logger_.log("Traffic Configuration File Processing Completed\n", true, false);
-      for (patternId = 0; patternId < trafficPattern_.size(); patternId++)
-      {
-        logger_.log("Traffic Pattern Type #"+toString(patternId+1), false, false);
-        trafficPattern_[patternId].printTrafficConfiguration(logger_);
-        logger_.log("", false, false);
-      }
-    }
-    else
-    {
-      logger_.log("ERROR - Unable To Open Traffic Configuration File: " + configurationFile_, false, true);
-      logger_.shutdownLogger();
-      exit(1);
-    }
-  }
-
-  void
-  initializeTrafficConfiguration()
-  {
-    if (boost::filesystem::exists(boost::filesystem::path(configurationFile_)))
-    {
-      if(boost::filesystem::is_regular_file(boost::filesystem::path(configurationFile_)))
-      {
-        analyzeConfigurationFile();
-      }
-      else
-      {
-        logger_.log("ERROR - Traffic Configuration File Is Not A Regular File: " + configurationFile_, false, true);
-        logger_.shutdownLogger();
-        exit(1);
-      }
-    }
-    else
-    {
-      logger_.log("ERROR - Traffic Configuration File Does Not Exist: " + configurationFile_, false, true);
-      logger_.shutdownLogger();
-      exit(1);
-    }
-  }
-
-  static std::string
-  getRandomByteString( int randomSize )
-  {
-    int i;
-    std::string characterSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvw0123456789";
-    std::string randomData;
-    for (i=0; i<randomSize; i++)
-      randomData += characterSet[std::rand() % characterSet.length()];
-    return randomData;
-  }
-
-  void
-  onInterest( const Name& name, const Interest& interest, int patternId )
-  {
-    std::string content, logLine;
-    content = "";
-    logLine = "";
-
-    Data data(interest.getName());
-    if (trafficPattern_[patternId].contentType >= 0)
-      data.setContentType(trafficPattern_[patternId].contentType);
-    if (trafficPattern_[patternId].freshnessPeriod >= 0)
-      data.setFreshnessPeriod(trafficPattern_[patternId].freshnessPeriod);
-    if (trafficPattern_[patternId].contentBytes >= 0)
-      content = getRandomByteString(trafficPattern_[patternId].contentBytes);
-    if (trafficPattern_[patternId].content != "")
-      content = trafficPattern_[patternId].content;
-    data.setContent((const uint8_t*)content.c_str(), content.length());
-    keyChain_.sign(data);
-    totalInterestReceived_++;
-    trafficPattern_[patternId].totalInterestReceived++;
-    logLine += "Interest Received          - PatternType="+toString(patternId+1);
-    logLine += ", GlobalID="+toString(totalInterestReceived_);
-    logLine += ", LocalID="+toString(trafficPattern_[patternId].totalInterestReceived);
-    logLine += ", Name="+trafficPattern_[patternId].name;
-    logger_.log(logLine, true, false);
-    usleep(contentDelayTime_*1000);
-    face_.put(data);
-  }
-
-  void
-  onRegisterFailed( const ndn::Name& prefix, const std::string& reason, int patternId )
-  {
-    std::string logLine;
-    logLine = "";
-    logLine += "Prefix Registration Failed - PatternType="+toString(patternId+1);
-    logLine += ", Name="+trafficPattern_[patternId].name;
-    logger_.log(logLine, true, true);
-    totalRegistrationsFailed_++;
-    if (totalRegistrationsFailed_ == trafficPattern_.size())
-      signalHandler();
-  }
-
-  void
-  initialize()
-  {
-    boost::asio::signal_set signalSet(*ioService_, SIGINT, SIGTERM);
-    signalSet.async_wait(boost::bind(&NdnTrafficServer::signalHandler, this));
-    logger_.initializeLog(instanceId_);
-    initializeTrafficConfiguration();
-
-    int patternId;
-    for (patternId=0; patternId<trafficPattern_.size(); patternId++ )
-    {
-      face_.setInterestFilter(  trafficPattern_[patternId].name,
-                                func_lib::bind( &NdnTrafficServer::onInterest,
-                                                this, _1, _2,
-                                                patternId),
-                                func_lib::bind( &NdnTrafficServer::onRegisterFailed,
-                                                this, _1, _2,
-                                                patternId));
-    }
-
-    try {
-      face_.processEvents();
-    }
-    catch(std::exception &e) {
-      logger_.log("ERROR: "+(std::string)e.what(), true, true);
-      logger_.shutdownLogger();
-    }
-  }
-
-private:
-
-  KeyChain keyChain_;
-  std::string programName_;
-  std::string instanceId_;
-  int contentDelayTime_;
-  int totalRegistrationsFailed_;
-  Logger logger_;
-  std::string configurationFile_;
-  ptr_lib::shared_ptr<boost::asio::io_service> ioService_;
-  Face face_;
-  std::vector<DataTrafficConfiguration> trafficPattern_;
-  int totalInterestReceived_;
-
-};
-
-int main( int argc, char* argv[] )
-{
-  int option;
-  NdnTrafficServer ndnTrafficServer (argv[0]);
-  while ((option = getopt(argc, argv, "hd:")) != -1) {
-    switch (option) {
-      case 'h'  :
-        ndnTrafficServer.usage();
-        break;
-      case 'd'  :
-        ndnTrafficServer.setContentDelayTime(atoi(optarg));
-        break;
-      default   :
-        ndnTrafficServer.usage();
-        break;
-    }
-  }
-
-  argc -= optind;
-  argv += optind;
-
-  if (argv[0] == NULL)
-    ndnTrafficServer.usage();
-
-  ndnTrafficServer.setConfigurationFile(argv[0]);
-  ndnTrafficServer.initialize();
-
-  return 0;
-}
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
+/**
+ * Copyright (C) 2014 University of Arizona.
+ *
+ * GNU 3.0 License, see the LICENSE file for more information
+ *
+ * Author: Jerald Paul Abraham <jeraldabraham@email.arizona.edu>
+ */
+
+#include <sstream>
+#include <boost/asio.hpp>
+#include <boost/filesystem.hpp>
+
+#include <ndn-cpp-dev/face.hpp>
+#include <ndn-cpp-dev/security/key-chain.hpp>
+
+#include "logger.hpp"
+
+namespace ndn {
+
+class NdnTrafficServer
+{
+public:
+  
+  NdnTrafficServer( char* programName )
+    : m_logger("NDNTrafficServer")
+    , ioService_(new boost::asio::io_service)
+    , face_(ioService_)
+    , keyChain_()
+  {
+    std::srand(std::time(0));
+    instanceId_ = toString(std::rand());
+    programName_ = programName;
+    contentDelayTime_ = getDefaultContentDelayTime();
+    totalRegistrationsFailed_ = 0;
+    configurationFile_ = "";
+    totalInterestReceived_ = 0;
+  }
+
+  class DataTrafficConfiguration
+  {
+  public:
+
+    DataTrafficConfiguration()
+    {
+      name = "";
+      contentType = -1;
+      freshnessPeriod = -1;
+      contentBytes = -1;
+      content = "";
+      totalInterestReceived = 0;
+    }
+
+    void
+    printTrafficConfiguration( Logger& logger )
+    {
+      std::string detail;
+      detail = "";
+      if (name != "")
+        detail += "Name="+name+", ";
+      if (contentType >= 0)
+        detail += "ContentType="+toString(contentType)+", ";
+      if (freshnessPeriod >= 0)
+        detail += "FreshnessPeriod="+toString(freshnessPeriod)+", ";
+      if (contentBytes >= 0)
+        detail += "ContentBytes="+toString(contentBytes)+", ";
+      if (content != "")
+        detail += "Content="+content+", ";
+      if (detail.length() >= 2)
+        detail = detail.substr(0, detail.length()-2);
+      logger.log(detail, false, false);
+    }
+
+
+    bool
+    extractParameterValue( std::string detail, std::string& parameter, std::string& value )
+    {
+      int i;
+      std::string allowedCharacters = ":/+._-%";
+      parameter = "";
+      value = "";
+      i = 0;
+      while (detail[i] != '=' && i < detail.length())
+        {
+          parameter += detail[i];
+          i++;
+        }
+      if (i == detail.length())
+        return false;
+      i++;
+      while ((std::isalnum(detail[i]) || allowedCharacters.find(detail[i]) != std::string::npos) && i < detail.length())
+        {
+          value += detail[i];
+          i++;
+        }
+      if(parameter == "" || value == "")
+        return false;
+      return true;
+    }
+
+    bool
+    processConfigurationDetail( std::string detail, Logger& logger, int lineNumber )
+    {
+      std::string parameter, value;
+      if (extractParameterValue(detail, parameter, value))
+        {
+          if (parameter == "Name")
+            name = value;
+          else if (parameter == "ContentType")
+            contentType = toInteger(value);
+          else if (parameter == "FreshnessPeriod")
+            freshnessPeriod = toInteger(value);
+          else if (parameter == "ContentBytes")
+            contentBytes = toInteger(value);
+          else if (parameter == "Content")
+            content = value;
+          else
+            logger.log("Line "+toString(lineNumber)+" \t- Invalid Parameter='"+parameter+"'", false, true);
+        }
+      else
+        {
+          logger.log("Line "+toString(lineNumber)+" \t- Improper Traffic Configuration Line- "+detail, false, true);
+          return false;
+        }
+      return true;
+    }
+
+    bool
+    checkTrafficDetailCorrectness()
+    {
+      return true;
+    }
+
+    std::string name;
+    int contentType;
+    int freshnessPeriod;
+    int contentBytes;
+    std::string content;
+    int totalInterestReceived;
+
+  };
+
+  std::string
+  getDefaultContent()
+  {
+    return "";
+  }
+
+  static std::string
+  toString( int integerValue )
+  {
+    std::stringstream stream;
+    stream << integerValue;
+    return stream.str();
+  }
+
+  static int
+  toInteger( std::string stringValue )
+  {
+    int integerValue;
+    std::stringstream stream(stringValue);
+    stream >> integerValue;
+    return integerValue;
+  }
+
+  void
+  usage()
+  {
+
+    std::cout << "\nUsage: " << programName_ << " [options] <Traffic_Configuration_File>\n"
+      "Respond to Interest as per provided Traffic Configuration File\n"
+      "Multiple Prefixes can be configured for handling.\n"
+      "Set environment variable NDN_TRAFFIC_LOGFOLDER for redirecting output to a log.\n"
+      "  [-d interval] - set delay before responding to interest in milliseconds (minimum "
+              << getDefaultContentDelayTime() << " milliseconds)\n"
+      "  [-h] - print help and exit\n\n";
+    exit(1);
+
+  }
+
+  int
+  getDefaultContentDelayTime()
+  {
+    return 0;
+  }
+
+  void
+  setContentDelayTime( int contentDelayTime )
+  {
+    if (contentDelayTime < 0)
+      usage();
+    contentDelayTime_ = contentDelayTime;
+  }
+
+  void
+  setConfigurationFile( char* configurationFile )
+  {
+    configurationFile_ = configurationFile;
+  }
+
+  void
+  signalHandler()
+  {
+    m_logger.shutdownLogger();
+    face_.shutdown();
+    ioService_.reset();
+    logStatistics();
+    exit(1);
+  }
+
+  void
+  logStatistics()
+  {
+    int patternId;
+    m_logger.log("\n\n== Interest Traffic Report ==\n", false, true);
+    m_logger.log("Total Traffic Pattern Types = "+toString((int)trafficPattern_.size()), false, true);
+    m_logger.log("Total Interests Received    = "+toString(totalInterestReceived_), false, true);
+    for (patternId=0; patternId<trafficPattern_.size(); patternId++)
+      {
+        m_logger.log("\nTraffic Pattern Type #"+toString(patternId+1), false, true);
+        trafficPattern_[patternId].printTrafficConfiguration(m_logger);
+        m_logger.log("Total Interests Received    = "+toString(trafficPattern_[patternId].totalInterestReceived)+"\n", false, true);
+      }
+  }
+
+  bool
+  checkTrafficPatternCorrectness()
+  {
+    return true;
+  }
+
+  void
+  analyzeConfigurationFile()
+  {
+    int patternId;
+    int lineNumber;
+    bool skipLine;
+    std::string patternLine;
+    std::ifstream patternFile;
+    m_logger.log("Analyzing Traffic Configuration File: " + configurationFile_, true, true);
+    patternFile.open(configurationFile_.c_str());
+    if (patternFile.is_open())
+      {
+        patternId = 0;
+        lineNumber = 0;
+        while (getline(patternFile, patternLine))
+          {
+            lineNumber++;
+            if (std::isalpha(patternLine[0]))
+              {
+                DataTrafficConfiguration dataData;
+                skipLine = false;
+                patternId++;
+                if (dataData.processConfigurationDetail(patternLine, m_logger, lineNumber))
+                  {
+                    while (getline(patternFile, patternLine) && std::isalpha(patternLine[0]))
+                      {
+                        lineNumber++;
+                        if (!dataData.processConfigurationDetail(patternLine, m_logger, lineNumber))
+                          {
+                            skipLine = true;
+                            break;
+                          }
+                      }
+                    lineNumber++;
+                  }
+                else
+                  skipLine = true;
+                if( !skipLine )
+                  {
+                    if (dataData.checkTrafficDetailCorrectness())
+                      trafficPattern_.push_back(dataData);
+                  }
+              }
+          }
+        patternFile.close();
+        if (!checkTrafficPatternCorrectness())
+          {
+            m_logger.log("ERROR - Traffic Configuration Provided Is Not Proper- " + configurationFile_, false, true);
+            m_logger.shutdownLogger();
+            exit(1);
+          }
+        m_logger.log("Traffic Configuration File Processing Completed\n", true, false);
+        for (patternId = 0; patternId < trafficPattern_.size(); patternId++)
+          {
+            m_logger.log("Traffic Pattern Type #"+toString(patternId+1), false, false);
+            trafficPattern_[patternId].printTrafficConfiguration(m_logger);
+            m_logger.log("", false, false);
+          }
+      }
+    else
+      {
+        m_logger.log("ERROR - Unable To Open Traffic Configuration File: " + configurationFile_, false, true);
+        m_logger.shutdownLogger();
+        exit(1);
+      }
+  }
+
+  void
+  initializeTrafficConfiguration()
+  {
+    if (boost::filesystem::exists(boost::filesystem::path(configurationFile_)))
+      {
+        if(boost::filesystem::is_regular_file(boost::filesystem::path(configurationFile_)))
+          {
+            analyzeConfigurationFile();
+          }
+        else
+          {
+            m_logger.log("ERROR - Traffic Configuration File Is Not A Regular File: " + configurationFile_, false, true);
+            m_logger.shutdownLogger();
+            exit(1);
+          }
+      }
+    else
+      {
+        m_logger.log("ERROR - Traffic Configuration File Does Not Exist: " + configurationFile_, false, true);
+        m_logger.shutdownLogger();
+        exit(1);
+      }
+  }
+
+  static std::string
+  getRandomByteString( int randomSize )
+  {
+    int i;
+    std::string characterSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvw0123456789";
+    std::string randomData;
+    for (i=0; i<randomSize; i++)
+      randomData += characterSet[std::rand() % characterSet.length()];
+    return randomData;
+  }
+
+  void
+  onInterest( const Name& name, const Interest& interest, int patternId )
+  {
+    std::string content, logLine;
+    content = "";
+    logLine = "";
+
+    Data data(interest.getName());
+    if (trafficPattern_[patternId].contentType >= 0)
+      data.setContentType(trafficPattern_[patternId].contentType);
+    if (trafficPattern_[patternId].freshnessPeriod >= 0)
+      data.setFreshnessPeriod(trafficPattern_[patternId].freshnessPeriod);
+    if (trafficPattern_[patternId].contentBytes >= 0)
+      content = getRandomByteString(trafficPattern_[patternId].contentBytes);
+    if (trafficPattern_[patternId].content != "")
+      content = trafficPattern_[patternId].content;
+    data.setContent((const uint8_t*)content.c_str(), content.length());
+    keyChain_.sign(data);
+    totalInterestReceived_++;
+    trafficPattern_[patternId].totalInterestReceived++;
+    logLine += "Interest Received          - PatternType="+toString(patternId+1);
+    logLine += ", GlobalID="+toString(totalInterestReceived_);
+    logLine += ", LocalID="+toString(trafficPattern_[patternId].totalInterestReceived);
+    logLine += ", Name="+trafficPattern_[patternId].name;
+    m_logger.log(logLine, true, false);
+    usleep(contentDelayTime_*1000);
+    face_.put(data);
+  }
+
+  void
+  onRegisterFailed( const ndn::Name& prefix, const std::string& reason, int patternId )
+  {
+    std::string logLine;
+    logLine = "";
+    logLine += "Prefix Registration Failed - PatternType="+toString(patternId+1);
+    logLine += ", Name="+trafficPattern_[patternId].name;
+    m_logger.log(logLine, true, true);
+    totalRegistrationsFailed_++;
+    if (totalRegistrationsFailed_ == trafficPattern_.size())
+      signalHandler();
+  }
+
+  void
+  initialize()
+  {
+    boost::asio::signal_set signalSet(*ioService_, SIGINT, SIGTERM);
+    signalSet.async_wait(boost::bind(&NdnTrafficServer::signalHandler, this));
+    m_logger.initializeLog(instanceId_);
+    initializeTrafficConfiguration();
+
+    int patternId;
+    for (patternId=0; patternId<trafficPattern_.size(); patternId++ )
+      {
+        face_.setInterestFilter(  trafficPattern_[patternId].name,
+                                  func_lib::bind( &NdnTrafficServer::onInterest,
+                                                  this, _1, _2,
+                                                  patternId),
+                                  func_lib::bind( &NdnTrafficServer::onRegisterFailed,
+                                                  this, _1, _2,
+                                                  patternId));
+      }
+
+    try {
+      face_.processEvents();
+    }
+    catch(std::exception &e) {
+      m_logger.log("ERROR: "+(std::string)e.what(), true, true);
+      m_logger.shutdownLogger();
+    }
+  }
+
+private:
+
+  KeyChain keyChain_;
+  std::string programName_;
+  std::string instanceId_;
+  int contentDelayTime_;
+  int totalRegistrationsFailed_;
+  Logger m_logger;
+  std::string configurationFile_;
+  ptr_lib::shared_ptr<boost::asio::io_service> ioService_;
+  Face face_;
+  std::vector<DataTrafficConfiguration> trafficPattern_;
+  int totalInterestReceived_;
+
+};
+
+} // namespace ndn
+
+int main( int argc, char* argv[] )
+{
+  int option;
+  ndn::NdnTrafficServer ndnTrafficServer (argv[0]);
+  while ((option = getopt(argc, argv, "hd:")) != -1) {
+    switch (option) {
+    case 'h'  :
+      ndnTrafficServer.usage();
+      break;
+    case 'd'  :
+      ndnTrafficServer.setContentDelayTime(atoi(optarg));
+      break;
+    default   :
+      ndnTrafficServer.usage();
+      break;
+    }
+  }
+
+  argc -= optind;
+  argv += optind;
+
+  if (argv[0] == NULL)
+    ndnTrafficServer.usage();
+
+  ndnTrafficServer.setConfigurationFile(argv[0]);
+  ndnTrafficServer.initialize();
+
+  return 0;
+}