DIFFS   [plain text]

	Submitting patches or diff's to the FreeRADIUS project

For a person or company wishing to submit a change to the
FreeRADIUS project, the process can sometimes be daunting if you're
not familiar with "the system." This text is a collection of
suggestions which can greatly increase the chances of your change
being accepted.


   1. "diff -u" 

      Use "diff -u" or "diff -urN" to create patches. 

      All changes to the source occur in the form of patches, as
      generated by diff(1).  When creating your patch, make sure to
      create it in "unified diff" format, as supplied by the '-u'
      argument to diff(1). Patches should be based in the root source
      directory, not in any lower subdirectory.

      To create a patch for a single file, it is often sufficient to do: 

           cd $SRCTREE
           cp $MYFILE $MYFILE.orig
           vi $MYFILE # make your change
           diff -u $MYFILE.orig $MYFILE > /tmp/patch 

      To create a patch for multiple files, you should unpack a
      "vanilla", or unmodified source tree, and generate a diff
      against your own source tree. For example:

	   gunzip freeradiusd-version.tar.gz
           tar xvf freeradiusd-version.tar
           diff -urN freeradiusd-version $MYSRC > ~/feature-version.patch

   2. Describe your changes. 

      Describe the technical detail of the change(s) your patch includes. 

      Be as specific as possible. The WORST descriptions possible
      include things like "update file X", "bug fix for file X",
      or "this patch includes updates for subsystem X. Please apply."

      If your description starts to get long, that's a sign that you
      probably need to split up your patch. See #3, next.

   3. Separate your changes. 

      Separate each logical change into its own patch.

      For example, if your changes include both bug fixes and
      performance enhancements for a single module, separate those
      changes into two or more patches.

      On the other hand, if you make a single change to numerous
      files, group those changes into a single patch. Thus a single
      LOGICAL change is contained within a single patch.

      If one patch depends on another patch in order for a change to
      be complete, that is OK. Simply note "this patch depends on
      patch X" in your patch description.

   4. Select e-mail destination. 

      If you are on the developers mailing list, send the patch there.

      Otherwise, send the patch to 'patches@freeradius.org'

   5. No MIME, no links, no compression, no attachments. Just plain text. 

      The developers need to be able to read and comment on the
      changes you are submitting. It is important for a developer to
      be able to "quote" your changes, using standard e-mail tools, so
      that they may comment on specific portions of your code.

      For this reason, all patches should be submitting e-mail

      Do not attach the patch as a MIME attachment, compressed or
      not. Many popular e-mail applications will not always transmit a
      MIME attachment as plain text, making it impossible to comment
      on your code. A MIME attachment also takes a bit more time to
      process, decreasing the likelihood of your MIME-attached change
      being accepted.

      Compressed patches are generally rejected outright.  If the
      developer has to do additional work to read your patch, the odds
      are that it will be ignored completely.

   6. E-mail size. 

      When sending patches, always follow step #5. 

      Large changes are not appropriate for mailing lists, and some
      maintainers. If your patch, exceeds 40Kb in size, it is
      preferred that you store your patch on an Internet-accessible
      server, and provide instead a URL (link) pointing to your patch.

   7. Name the version of the server.

      It is important to note, either in the subject line or in the
      patch description, the server version to which this patch

   8. Don't get discouraged. Re-submit. 

      After you have submitted your change, be patient and wait. If
      the patch is approved and applied, it will appear in the next
      version of the server.

      However, if your change doesn't appear in the next version of
      the server, there could be any number of reasons. It's YOUR job
      to narrow down those reasons, correct what was wrong, and submit
      your updated change.

      It is quite common a patch to be "dropped" without
      comment. That's the nature of the system. If your patch is
      dropped, it could be due to

           A style issue (see section 2, below),
           An e-mail formatting issue (see section item 5, above)
           A technical problem with your change 
           Your patch got lost among other patches

      When in doubt, re-submit.


This section lists many of the common "rules" associated with code
submitted to the project. There are always exceptions... but you must
have a really good reason for doing so.

   1. Read the Documentation and follow the CodingStyle 

      The FreeRADIUS server has a common coding style.  Use real tabs
	  to indent.  There is whitespace in variable assignments.
      (i = 1, NOT i=1).

      When in doubt, format your code to look the same as code already
      in the server.  If your code deviates too much from the current
      style, it is likely to be rejected without further review, and
      without comment.

   2. #ifdefs are ugly 

      Code cluttered with ifdefs is difficult to read and
      maintain. Don't do it. Instead, put your ifdefs in a header, and
      conditionally define 'static inline' functions, or macros, which
      are used in the code. Let the compiler optimize away the "no-op"

      Simple example, of poor code: 

           #ifdef CONFIG_MY_FUNKINESS 

      Cleaned-up example: 

      (in header) 

           #ifndef CONFIG_MY_FUNKINESS
           static inline void init_my_stuff(char *foo) {}

      (in the code itself) 


   3. 'static inline' is better than a macro 

      Static inline functions are greatly preferred over macros. They
      provide type safety, have no length limitations, no formatting
      limitations, and under gcc they are as cheap as macros.

      Macros should only be used for cases where a static inline is
      clearly suboptimal [there a few, isolated cases of this in fast
      paths], or where it is impossible to use a static inline
      function [such as string-izing].

      'static inline' is preferred over 'static __inline__', 'extern
      inline', and 'extern __inline__'.

   4. Don't over-design. 

      Don't try to anticipate nebulous future cases which may or may
      not be useful: "Make it as simple as you can, and no simpler"

      Split up functionality as much as possible.  If your code needs
      to do two unrelated things, write two functions.  Mashing two
      kinds of work into one function makes the server difficult to
      debug and maintain.

      See the 'coding-methods.txt' document in this directory for
      further description of coding methods.