diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000..4adfdaa
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,1076 @@
+jnr-posix is released under a tri EPL/GPL/LGPL license. You can use it,
+redistribute it and/or modify it under the terms of the:
+
+  Eclipse Public License version 2.0
+    OR
+  GNU General Public License version 2
+    OR
+  GNU Lesser General Public License version 2.1
+
+The complete text of the Eclipse Public License is as follows:
+
+  Eclipse Public License - v 2.0
+
+      THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+      PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION
+      OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+  1. DEFINITIONS
+
+  "Contribution" means:
+
+    a) in the case of the initial Contributor, the initial content
+       Distributed under this Agreement, and
+
+    b) in the case of each subsequent Contributor:
+       i) changes to the Program, and
+       ii) additions to the Program;
+    where such changes and/or additions to the Program originate from
+    and are Distributed by that particular Contributor. A Contribution
+    "originates" from a Contributor if it was added to the Program by
+    such Contributor itself or anyone acting on such Contributor's behalf.
+    Contributions do not include changes or additions to the Program that
+    are not Modified Works.
+
+  "Contributor" means any person or entity that Distributes the Program.
+
+  "Licensed Patents" mean patent claims licensable by a Contributor which
+  are necessarily infringed by the use or sale of its Contribution alone
+  or when combined with the Program.
+
+  "Program" means the Contributions Distributed in accordance with this
+  Agreement.
+
+  "Recipient" means anyone who receives the Program under this Agreement
+  or any Secondary License (as applicable), including Contributors.
+
+  "Derivative Works" shall mean any work, whether in Source Code or other
+  form, that is based on (or derived from) the Program and for which the
+  editorial revisions, annotations, elaborations, or other modifications
+  represent, as a whole, an original work of authorship.
+
+  "Modified Works" shall mean any work in Source Code or other form that
+  results from an addition to, deletion from, or modification of the
+  contents of the Program, including, for purposes of clarity any new file
+  in Source Code form that contains any contents of the Program. Modified
+  Works shall not include works that contain only declarations,
+  interfaces, types, classes, structures, or files of the Program solely
+  in each case in order to link to, bind by name, or subclass the Program
+  or Modified Works thereof.
+
+  "Distribute" means the acts of a) distributing or b) making available
+  in any manner that enables the transfer of a copy.
+
+  "Source Code" means the form of a Program preferred for making
+  modifications, including but not limited to software source code,
+  documentation source, and configuration files.
+
+  "Secondary License" means either the GNU General Public License,
+  Version 2.0, or any later versions of that license, including any
+  exceptions or additional permissions as identified by the initial
+  Contributor.
+
+  2. GRANT OF RIGHTS
+
+    a) Subject to the terms of this Agreement, each Contributor hereby
+    grants Recipient a non-exclusive, worldwide, royalty-free copyright
+    license to reproduce, prepare Derivative Works of, publicly display,
+    publicly perform, Distribute and sublicense the Contribution of such
+    Contributor, if any, and such Derivative Works.
+
+    b) Subject to the terms of this Agreement, each Contributor hereby
+    grants Recipient a non-exclusive, worldwide, royalty-free patent
+    license under Licensed Patents to make, use, sell, offer to sell,
+    import and otherwise transfer the Contribution of such Contributor,
+    if any, in Source Code or other form. This patent license shall
+    apply to the combination of the Contribution and the Program if, at
+    the time the Contribution is added by the Contributor, such addition
+    of the Contribution causes such combination to be covered by the
+    Licensed Patents. The patent license shall not apply to any other
+    combinations which include the Contribution. No hardware per se is
+    licensed hereunder.
+
+    c) Recipient understands that although each Contributor grants the
+    licenses to its Contributions set forth herein, no assurances are
+    provided by any Contributor that the Program does not infringe the
+    patent or other intellectual property rights of any other entity.
+    Each Contributor disclaims any liability to Recipient for claims
+    brought by any other entity based on infringement of intellectual
+    property rights or otherwise. As a condition to exercising the
+    rights and licenses granted hereunder, each Recipient hereby
+    assumes sole responsibility to secure any other intellectual
+    property rights needed, if any. For example, if a third party
+    patent license is required to allow Recipient to Distribute the
+    Program, it is Recipient's responsibility to acquire that license
+    before distributing the Program.
+
+    d) Each Contributor represents that to its knowledge it has
+    sufficient copyright rights in its Contribution, if any, to grant
+    the copyright license set forth in this Agreement.
+
+    e) Notwithstanding the terms of any Secondary License, no
+    Contributor makes additional grants to any Recipient (other than
+    those set forth in this Agreement) as a result of such Recipient's
+    receipt of the Program under the terms of a Secondary License
+    (if permitted under the terms of Section 3).
+
+  3. REQUIREMENTS
+
+  3.1 If a Contributor Distributes the Program in any form, then:
+
+    a) the Program must also be made available as Source Code, in
+    accordance with section 3.2, and the Contributor must accompany
+    the Program with a statement that the Source Code for the Program
+    is available under this Agreement, and informs Recipients how to
+    obtain it in a reasonable manner on or through a medium customarily
+    used for software exchange; and
+
+    b) the Contributor may Distribute the Program under a license
+    different than this Agreement, provided that such license:
+       i) effectively disclaims on behalf of all other Contributors all
+       warranties and conditions, express and implied, including
+       warranties or conditions of title and non-infringement, and
+       implied warranties or conditions of merchantability and fitness
+       for a particular purpose;
+
+       ii) effectively excludes on behalf of all other Contributors all
+       liability for damages, including direct, indirect, special,
+       incidental and consequential damages, such as lost profits;
+
+       iii) does not attempt to limit or alter the recipients' rights
+       in the Source Code under section 3.2; and
+
+       iv) requires any subsequent distribution of the Program by any
+       party to be under a license that satisfies the requirements
+       of this section 3.
+
+  3.2 When the Program is Distributed as Source Code:
+
+    a) it must be made available under this Agreement, or if the
+    Program (i) is combined with other material in a separate file or
+    files made available under a Secondary License, and (ii) the initial
+    Contributor attached to the Source Code the notice described in
+    Exhibit A of this Agreement, then the Program may be made available
+    under the terms of such Secondary Licenses, and
+
+    b) a copy of this Agreement must be included with each copy of
+    the Program.
+
+  3.3 Contributors may not remove or alter any copyright, patent,
+  trademark, attribution notices, disclaimers of warranty, or limitations
+  of liability ("notices") contained within the Program from any copy of
+  the Program which they Distribute, provided that Contributors may add
+  their own appropriate notices.
+
+  4. COMMERCIAL DISTRIBUTION
+
+  Commercial distributors of software may accept certain responsibilities
+  with respect to end users, business partners and the like. While this
+  license is intended to facilitate the commercial use of the Program,
+  the Contributor who includes the Program in a commercial product
+  offering should do so in a manner which does not create potential
+  liability for other Contributors. Therefore, if a Contributor includes
+  the Program in a commercial product offering, such Contributor
+  ("Commercial Contributor") hereby agrees to defend and indemnify every
+  other Contributor ("Indemnified Contributor") against any losses,
+  damages and costs (collectively "Losses") arising from claims, lawsuits
+  and other legal actions brought by a third party against the Indemnified
+  Contributor to the extent caused by the acts or omissions of such
+  Commercial Contributor in connection with its distribution of the Program
+  in a commercial product offering. The obligations in this section do not
+  apply to any claims or Losses relating to any actual or alleged
+  intellectual property infringement. In order to qualify, an Indemnified
+  Contributor must: a) promptly notify the Commercial Contributor in
+  writing of such claim, and b) allow the Commercial Contributor to control,
+  and cooperate with the Commercial Contributor in, the defense and any
+  related settlement negotiations. The Indemnified Contributor may
+  participate in any such claim at its own expense.
+
+  For example, a Contributor might include the Program in a commercial
+  product offering, Product X. That Contributor is then a Commercial
+  Contributor. If that Commercial Contributor then makes performance
+  claims, or offers warranties related to Product X, those performance
+  claims and warranties are such Commercial Contributor's responsibility
+  alone. Under this section, the Commercial Contributor would have to
+  defend claims against the other Contributors related to those performance
+  claims and warranties, and if a court requires any other Contributor to
+  pay any damages as a result, the Commercial Contributor must pay
+  those damages.
+
+  5. NO WARRANTY
+
+  EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+  PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS"
+  BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+  IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF
+  TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
+  PURPOSE. Each Recipient is solely responsible for determining the
+  appropriateness of using and distributing the Program and assumes all
+  risks associated with its exercise of rights under this Agreement,
+  including but not limited to the risks and costs of program errors,
+  compliance with applicable laws, damage to or loss of data, programs
+  or equipment, and unavailability or interruption of operations.
+
+  6. DISCLAIMER OF LIABILITY
+
+  EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+  PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS
+  SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+  PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+  EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGES.
+
+  7. GENERAL
+
+  If any provision of this Agreement is invalid or unenforceable under
+  applicable law, it shall not affect the validity or enforceability of
+  the remainder of the terms of this Agreement, and without further
+  action by the parties hereto, such provision shall be reformed to the
+  minimum extent necessary to make such provision valid and enforceable.
+
+  If Recipient institutes patent litigation against any entity
+  (including a cross-claim or counterclaim in a lawsuit) alleging that the
+  Program itself (excluding combinations of the Program with other software
+  or hardware) infringes such Recipient's patent(s), then such Recipient's
+  rights granted under Section 2(b) shall terminate as of the date such
+  litigation is filed.
+
+  All Recipient's rights under this Agreement shall terminate if it
+  fails to comply with any of the material terms or conditions of this
+  Agreement and does not cure such failure in a reasonable period of
+  time after becoming aware of such noncompliance. If all Recipient's
+  rights under this Agreement terminate, Recipient agrees to cease use
+  and distribution of the Program as soon as reasonably practicable.
+  However, Recipient's obligations under this Agreement and any licenses
+  granted by Recipient relating to the Program shall continue and survive.
+
+  Everyone is permitted to copy and distribute copies of this Agreement,
+  but in order to avoid inconsistency the Agreement is copyrighted and
+  may only be modified in the following manner. The Agreement Steward
+  reserves the right to publish new versions (including revisions) of
+  this Agreement from time to time. No one other than the Agreement
+  Steward has the right to modify this Agreement. The Eclipse Foundation
+  is the initial Agreement Steward. The Eclipse Foundation may assign the
+  responsibility to serve as the Agreement Steward to a suitable separate
+  entity. Each new version of the Agreement will be given a distinguishing
+  version number. The Program (including Contributions) may always be
+  Distributed subject to the version of the Agreement under which it was
+  received. In addition, after a new version of the Agreement is published,
+  Contributor may elect to Distribute the Program (including its
+  Contributions) under the new version.
+
+  Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+  receives no rights or licenses to the intellectual property of any
+  Contributor under this Agreement, whether expressly, by implication,
+  estoppel or otherwise. All rights in the Program not expressly granted
+  under this Agreement are reserved. Nothing in this Agreement is intended
+  to be enforceable by any entity that is not a Contributor or Recipient.
+  No third-party beneficiary rights are created under this Agreement.
+
+  Exhibit A - Form of Secondary Licenses Notice
+
+  "This Source Code may also be made available under the following
+  Secondary Licenses when the conditions for such availability set forth
+  in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+  version(s), and exceptions or additional permissions here}."
+
+    Simply including a copy of this Agreement, including this Exhibit A
+    is not sufficient to license the Source Code under Secondary Licenses.
+
+    If it is not possible or desirable to put the notice in a particular
+    file, then You may include the notice in a location (such as a LICENSE
+    file in a relevant directory) where a recipient would be likely to
+    look for such a notice.
+
+    You may add additional accurate notices of copyright ownership.
+
+The complete text of the GNU General Public License v2 is as follows:
+
+          GNU GENERAL PUBLIC LICENSE
+             Version 2, June 1991
+
+   Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                         59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+   Everyone is permitted to copy and distribute verbatim copies
+   of this license document, but changing it is not allowed.
+
+            Preamble
+
+    The licenses for most software are designed to take away your
+  freedom to share and change it.  By contrast, the GNU General Public
+  License is intended to guarantee your freedom to share and change free
+  software--to make sure the software is free for all its users.  This
+  General Public License applies to most of the Free Software
+  Foundation's software and to any other program whose authors commit to
+  using it.  (Some other Free Software Foundation software is covered by
+  the GNU Library General Public License instead.)  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
+  this service 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 make restrictions that forbid
+  anyone to deny you these rights or to ask you to surrender the rights.
+  These restrictions translate to certain responsibilities for you if you
+  distribute copies of the software, or if you modify it.
+
+    For example, if you distribute copies of such a program, whether
+  gratis or for a fee, you must give the recipients all the rights that
+  you have.  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.
+
+    We protect your rights with two steps: (1) copyright the software, and
+  (2) offer you this license which gives you legal permission to copy,
+  distribute and/or modify the software.
+
+    Also, for each author's protection and ours, we want to make certain
+  that everyone understands that there is no warranty for this free
+  software.  If the software is modified by someone else and passed on, we
+  want its recipients to know that what they have is not the original, so
+  that any problems introduced by others will not reflect on the original
+  authors' reputations.
+
+    Finally, any free program is threatened constantly by software
+  patents.  We wish to avoid the danger that redistributors of a free
+  program will individually obtain patent licenses, in effect making the
+  program proprietary.  To prevent this, we have made it clear that any
+  patent must be licensed for everyone's free use or not licensed at all.
+
+    The precise terms and conditions for copying, distribution and
+  modification follow.
+
+          GNU GENERAL PUBLIC LICENSE
+     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+    0. This License applies to any program or other work which contains
+  a notice placed by the copyright holder saying it may be distributed
+  under the terms of this General Public License.  The "Program", below,
+  refers to any such program or work, and a "work based on the Program"
+  means either the Program or any derivative work under copyright law:
+  that is to say, a work containing the Program or a portion of it,
+  either verbatim or with modifications and/or translated into another
+  language.  (Hereinafter, translation is included without limitation in
+  the term "modification".)  Each licensee is addressed as "you".
+
+  Activities other than copying, distribution and modification are not
+  covered by this License; they are outside its scope.  The act of
+  running the Program is not restricted, and the output from the Program
+  is covered only if its contents constitute a work based on the
+  Program (independent of having been made by running the Program).
+  Whether that is true depends on what the Program does.
+
+    1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the
+  notices that refer to this License and to the absence of any warranty;
+  and give any other recipients of the Program a copy of this License
+  along with the Program.
+
+  You may charge a fee for the physical act of transferring a copy, and
+  you may at your option offer warranty protection in exchange for a fee.
+
+    2. You may modify your copy or copies of the Program or any portion
+  of it, thus forming a work based on the Program, and copy and
+  distribute such modifications or work under the terms of Section 1
+  above, provided that you also meet all of these conditions:
+
+      a) You must cause the modified files to carry prominent notices
+      stating that you changed the files and the date of any change.
+
+      b) You must cause any work that you distribute or publish, that in
+      whole or in part contains or is derived from the Program or any
+      part thereof, to be licensed as a whole at no charge to all third
+      parties under the terms of this License.
+
+      c) If the modified program normally reads commands interactively
+      when run, you must cause it, when started running for such
+      interactive use in the most ordinary way, to print or display an
+      announcement including an appropriate copyright notice and a
+      notice that there is no warranty (or else, saying that you provide
+      a warranty) and that users may redistribute the program under
+      these conditions, and telling the user how to view a copy of this
+      License.  (Exception: if the Program itself is interactive but
+      does not normally print such an announcement, your work based on
+      the Program is not required to print an announcement.)
+
+  These requirements apply to the modified work as a whole.  If
+  identifiable sections of that work are not derived from the Program,
+  and can be reasonably considered independent and separate works in
+  themselves, then this License, and its terms, do not apply to those
+  sections when you distribute them as separate works.  But when you
+  distribute the same sections as part of a whole which is a work based
+  on the Program, the distribution of the whole must be on the terms of
+  this License, whose permissions for other licensees extend to the
+  entire whole, and thus to each and every part regardless of who wrote it.
+
+  Thus, it is not the intent of this section to claim rights or contest
+  your rights to work written entirely by you; rather, the intent is to
+  exercise the right to control the distribution of derivative or
+  collective works based on the Program.
+
+  In addition, mere aggregation of another work not based on the Program
+  with the Program (or with a work based on the Program) on a volume of
+  a storage or distribution medium does not bring the other work under
+  the scope of this License.
+
+    3. You may copy and distribute the Program (or a work based on it,
+  under Section 2) in object code or executable form under the terms of
+  Sections 1 and 2 above provided that you also do one of the following:
+
+      a) Accompany it with the complete corresponding machine-readable
+      source code, which must be distributed under the terms of Sections
+      1 and 2 above on a medium customarily used for software interchange; or,
+
+      b) Accompany it with a written offer, valid for at least three
+      years, to give any third party, for a charge no more than your
+      cost of physically performing source distribution, a complete
+      machine-readable copy of the corresponding source code, to be
+      distributed under the terms of Sections 1 and 2 above on a medium
+      customarily used for software interchange; or,
+
+      c) Accompany it with the information you received as to the offer
+      to distribute corresponding source code.  (This alternative is
+      allowed only for noncommercial distribution and only if you
+      received the program in object code or executable form with such
+      an offer, in accord with Subsection b above.)
+
+  The source code for a work means the preferred form of the work for
+  making modifications to it.  For an executable work, complete source
+  code means all the source code for all modules it contains, plus any
+  associated interface definition files, plus the scripts used to
+  control compilation and installation of the executable.  However, as a
+  special exception, the source code distributed need not include
+  anything that is normally distributed (in either source or binary
+  form) with the major components (compiler, kernel, and so on) of the
+  operating system on which the executable runs, unless that component
+  itself accompanies the executable.
+
+  If distribution of executable or object code is made by offering
+  access to copy from a designated place, then offering equivalent
+  access to copy the source code from the same place counts as
+  distribution of the source code, even though third parties are not
+  compelled to copy the source along with the object code.
+
+    4. You may not copy, modify, sublicense, or distribute the Program
+  except as expressly provided under this License.  Any attempt
+  otherwise to copy, modify, sublicense or distribute the Program is
+  void, and will automatically terminate your rights under this License.
+  However, parties who have received copies, or rights, from you under
+  this License will not have their licenses terminated so long as such
+  parties remain in full compliance.
+
+    5. You are not required to accept this License, since you have not
+  signed it.  However, nothing else grants you permission to modify or
+  distribute the Program or its derivative works.  These actions are
+  prohibited by law if you do not accept this License.  Therefore, by
+  modifying or distributing the Program (or any work based on the
+  Program), you indicate your acceptance of this License to do so, and
+  all its terms and conditions for copying, distributing or modifying
+  the Program or works based on it.
+
+    6. Each time you redistribute the Program (or any work based on the
+  Program), the recipient automatically receives a license from the
+  original licensor to copy, distribute or modify the Program subject to
+  these terms and conditions.  You may not impose any further
+  restrictions on the recipients' exercise of the rights granted herein.
+  You are not responsible for enforcing compliance by third parties to
+  this License.
+
+    7. If, as a consequence of a court judgment or allegation of patent
+  infringement or for any other reason (not limited to patent issues),
+  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
+  distribute so as to satisfy simultaneously your obligations under this
+  License and any other pertinent obligations, then as a consequence you
+  may not distribute the Program at all.  For example, if a patent
+  license would not permit royalty-free redistribution of the Program by
+  all those who receive copies directly or indirectly through you, then
+  the only way you could satisfy both it and this License would be to
+  refrain entirely from distribution of the Program.
+
+  If any portion of this section is held invalid or unenforceable under
+  any particular circumstance, the balance of the section is intended to
+  apply and the section as a whole is intended to apply in other
+  circumstances.
+
+  It is not the purpose of this section to induce you to infringe any
+  patents or other property right claims or to contest validity of any
+  such claims; this section has the sole purpose of protecting the
+  integrity of the free software distribution system, which is
+  implemented by public license practices.  Many people have made
+  generous contributions to the wide range of software distributed
+  through that system in reliance on consistent application of that
+  system; it is up to the author/donor to decide if he or she is willing
+  to distribute software through any other system and a licensee cannot
+  impose that choice.
+
+  This section is intended to make thoroughly clear what is believed to
+  be a consequence of the rest of this License.
+
+    8. If the distribution and/or use of the Program is restricted in
+  certain countries either by patents or by copyrighted interfaces, the
+  original copyright holder who places the Program under this License
+  may add an explicit geographical distribution limitation excluding
+  those countries, so that distribution is permitted only in or among
+  countries not thus excluded.  In such case, this License incorporates
+  the limitation as if written in the body of this License.
+
+    9. The Free Software Foundation may publish revised and/or new versions
+  of the 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 a version number of this License which applies to it and "any
+  later version", you have the option of following the terms and conditions
+  either of that version or of any later version published by the Free
+  Software Foundation.  If the Program does not specify a version number of
+  this License, you may choose any version ever published by the Free Software
+  Foundation.
+
+    10. If you wish to incorporate parts of the Program into other free
+  programs whose distribution conditions are different, write to the author
+  to ask for permission.  For software which is copyrighted by the Free
+  Software Foundation, write to the Free Software Foundation; we sometimes
+  make exceptions for this.  Our decision will be guided by the two goals
+  of preserving the free status of all derivatives of our free software and
+  of promoting the sharing and reuse of software generally.
+
+            NO WARRANTY
+
+    11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.
+
+    12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+  WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+  REDISTRIBUTE 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.
+
+           END OF TERMS AND CONDITIONS
+
+The complete text of the GNU Lesser General Public License 2.1 is as follows:
+
+        GNU LESSER GENERAL PUBLIC LICENSE
+             Version 2.1, February 1999
+
+   Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+   Everyone is permitted to copy and distribute verbatim copies
+   of this license document, but changing it is not allowed.
+
+  [This is the first released version of the Lesser GPL.  It also counts
+   as the successor of the GNU Library Public License, version 2, hence
+   the version number 2.1.]
+
+            Preamble
+
+    The licenses for most software are designed to take away your
+  freedom to share and change it.  By contrast, the GNU General Public
+  Licenses are intended to guarantee your freedom to share and change
+  free software--to make sure the software is free for all its users.
+
+    This license, the Lesser General Public License, applies to some
+  specially designated software packages--typically libraries--of the
+  Free Software Foundation and other authors who decide to use it.  You
+  can use it too, but we suggest you first think carefully about whether
+  this license or the ordinary General Public License is the better
+  strategy to use in any particular case, based on the explanations below.
+
+    When we speak of free software, we are referring to freedom of use,
+  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 this service if you wish); that you receive source code or can get
+  it if you want it; that you can change the software and use pieces of
+  it in new free programs; and that you are informed that you can do
+  these things.
+
+    To protect your rights, we need to make restrictions that forbid
+  distributors to deny you these rights or to ask you to surrender these
+  rights.  These restrictions translate to certain responsibilities for
+  you if you distribute copies of the library or if you modify it.
+
+    For example, if you distribute copies of the library, whether gratis
+  or for a fee, you must give the recipients all the rights that we gave
+  you.  You must make sure that they, too, receive or can get the source
+  code.  If you link other code with the library, you must provide
+  complete object files to the recipients, so that they can relink them
+  with the library after making changes to the library and recompiling
+  it.  And you must show them these terms so they know their rights.
+
+    We protect your rights with a two-step method: (1) we copyright the
+  library, and (2) we offer you this license, which gives you legal
+  permission to copy, distribute and/or modify the library.
+
+    To protect each distributor, we want to make it very clear that
+  there is no warranty for the free library.  Also, if the library is
+  modified by someone else and passed on, the recipients should know
+  that what they have is not the original version, so that the original
+  author's reputation will not be affected by problems that might be
+  introduced by others.
+
+    Finally, software patents pose a constant threat to the existence of
+  any free program.  We wish to make sure that a company cannot
+  effectively restrict the users of a free program by obtaining a
+  restrictive license from a patent holder.  Therefore, we insist that
+  any patent license obtained for a version of the library must be
+  consistent with the full freedom of use specified in this license.
+
+    Most GNU software, including some libraries, is covered by the
+  ordinary GNU General Public License.  This license, the GNU Lesser
+  General Public License, applies to certain designated libraries, and
+  is quite different from the ordinary General Public License.  We use
+  this license for certain libraries in order to permit linking those
+  libraries into non-free programs.
+
+    When a program is linked with a library, whether statically or using
+  a shared library, the combination of the two is legally speaking a
+  combined work, a derivative of the original library.  The ordinary
+  General Public License therefore permits such linking only if the
+  entire combination fits its criteria of freedom.  The Lesser General
+  Public License permits more lax criteria for linking other code with
+  the library.
+
+    We call this license the "Lesser" General Public License because it
+  does Less to protect the user's freedom than the ordinary General
+  Public License.  It also provides other free software developers Less
+  of an advantage over competing non-free programs.  These disadvantages
+  are the reason we use the ordinary General Public License for many
+  libraries.  However, the Lesser license provides advantages in certain
+  special circumstances.
+
+    For example, on rare occasions, there may be a special need to
+  encourage the widest possible use of a certain library, so that it becomes
+  a de-facto standard.  To achieve this, non-free programs must be
+  allowed to use the library.  A more frequent case is that a free
+  library does the same job as widely used non-free libraries.  In this
+  case, there is little to gain by limiting the free library to free
+  software only, so we use the Lesser General Public License.
+
+    In other cases, permission to use a particular library in non-free
+  programs enables a greater number of people to use a large body of
+  free software.  For example, permission to use the GNU C Library in
+  non-free programs enables many more people to use the whole GNU
+  operating system, as well as its variant, the GNU/Linux operating
+  system.
+
+    Although the Lesser General Public License is Less protective of the
+  users' freedom, it does ensure that the user of a program that is
+  linked with the Library has the freedom and the wherewithal to run
+  that program using a modified version of the Library.
+
+    The precise terms and conditions for copying, distribution and
+  modification follow.  Pay close attention to the difference between a
+  "work based on the library" and a "work that uses the library".  The
+  former contains code derived from the library, whereas the latter must
+  be combined with the library in order to run.
+
+        GNU LESSER GENERAL PUBLIC LICENSE
+     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+    0. This License Agreement applies to any software library or other
+  program which contains a notice placed by the copyright holder or
+  other authorized party saying it may be distributed under the terms of
+  this Lesser General Public License (also called "this License").
+  Each licensee is addressed as "you".
+
+    A "library" means a collection of software functions and/or data
+  prepared so as to be conveniently linked with application programs
+  (which use some of those functions and data) to form executables.
+
+    The "Library", below, refers to any such software library or work
+  which has been distributed under these terms.  A "work based on the
+  Library" means either the Library or any derivative work under
+  copyright law: that is to say, a work containing the Library or a
+  portion of it, either verbatim or with modifications and/or translated
+  straightforwardly into another language.  (Hereinafter, translation is
+  included without limitation in the term "modification".)
+
+    "Source code" for a work means the preferred form of the work for
+  making modifications to it.  For a library, complete source code means
+  all the source code for all modules it contains, plus any associated
+  interface definition files, plus the scripts used to control compilation
+  and installation of the library.
+
+    Activities other than copying, distribution and modification are not
+  covered by this License; they are outside its scope.  The act of
+  running a program using the Library is not restricted, and output from
+  such a program is covered only if its contents constitute a work based
+  on the Library (independent of the use of the Library in a tool for
+  writing it).  Whether that is true depends on what the Library does
+  and what the program that uses the Library does.
+  
+    1. You may copy and distribute verbatim copies of the Library's
+  complete source code as you receive it, in any medium, provided that
+  you conspicuously and appropriately publish on each copy an
+  appropriate copyright notice and disclaimer of warranty; keep intact
+  all the notices that refer to this License and to the absence of any
+  warranty; and distribute a copy of this License along with the
+  Library.
+
+    You may charge a fee for the physical act of transferring a copy,
+  and you may at your option offer warranty protection in exchange for a
+  fee.
+
+    2. You may modify your copy or copies of the Library or any portion
+  of it, thus forming a work based on the Library, and copy and
+  distribute such modifications or work under the terms of Section 1
+  above, provided that you also meet all of these conditions:
+
+      a) The modified work must itself be a software library.
+
+      b) You must cause the files modified to carry prominent notices
+      stating that you changed the files and the date of any change.
+
+      c) You must cause the whole of the work to be licensed at no
+      charge to all third parties under the terms of this License.
+
+      d) If a facility in the modified Library refers to a function or a
+      table of data to be supplied by an application program that uses
+      the facility, other than as an argument passed when the facility
+      is invoked, then you must make a good faith effort to ensure that,
+      in the event an application does not supply such function or
+      table, the facility still operates, and performs whatever part of
+      its purpose remains meaningful.
+
+      (For example, a function in a library to compute square roots has
+      a purpose that is entirely well-defined independent of the
+      application.  Therefore, Subsection 2d requires that any
+      application-supplied function or table used by this function must
+      be optional: if the application does not supply it, the square
+      root function must still compute square roots.)
+
+  These requirements apply to the modified work as a whole.  If
+  identifiable sections of that work are not derived from the Library,
+  and can be reasonably considered independent and separate works in
+  themselves, then this License, and its terms, do not apply to those
+  sections when you distribute them as separate works.  But when you
+  distribute the same sections as part of a whole which is a work based
+  on the Library, the distribution of the whole must be on the terms of
+  this License, whose permissions for other licensees extend to the
+  entire whole, and thus to each and every part regardless of who wrote
+  it.
+
+  Thus, it is not the intent of this section to claim rights or contest
+  your rights to work written entirely by you; rather, the intent is to
+  exercise the right to control the distribution of derivative or
+  collective works based on the Library.
+
+  In addition, mere aggregation of another work not based on the Library
+  with the Library (or with a work based on the Library) on a volume of
+  a storage or distribution medium does not bring the other work under
+  the scope of this License.
+
+    3. You may opt to apply the terms of the ordinary GNU General Public
+  License instead of this License to a given copy of the Library.  To do
+  this, you must alter all the notices that refer to this License, so
+  that they refer to the ordinary GNU General Public License, version 2,
+  instead of to this License.  (If a newer version than version 2 of the
+  ordinary GNU General Public License has appeared, then you can specify
+  that version instead if you wish.)  Do not make any other change in
+  these notices.
+
+    Once this change is made in a given copy, it is irreversible for
+  that copy, so the ordinary GNU General Public License applies to all
+  subsequent copies and derivative works made from that copy.
+
+    This option is useful when you wish to copy part of the code of
+  the Library into a program that is not a library.
+
+    4. You may copy and distribute the Library (or a portion or
+  derivative of it, under Section 2) in object code or executable form
+  under the terms of Sections 1 and 2 above provided that you accompany
+  it with the complete corresponding machine-readable source code, which
+  must be distributed under the terms of Sections 1 and 2 above on a
+  medium customarily used for software interchange.
+
+    If distribution of object code is made by offering access to copy
+  from a designated place, then offering equivalent access to copy the
+  source code from the same place satisfies the requirement to
+  distribute the source code, even though third parties are not
+  compelled to copy the source along with the object code.
+
+    5. A program that contains no derivative of any portion of the
+  Library, but is designed to work with the Library by being compiled or
+  linked with it, is called a "work that uses the Library".  Such a
+  work, in isolation, is not a derivative work of the Library, and
+  therefore falls outside the scope of this License.
+
+    However, linking a "work that uses the Library" with the Library
+  creates an executable that is a derivative of the Library (because it
+  contains portions of the Library), rather than a "work that uses the
+  library".  The executable is therefore covered by this License.
+  Section 6 states terms for distribution of such executables.
+
+    When a "work that uses the Library" uses material from a header file
+  that is part of the Library, the object code for the work may be a
+  derivative work of the Library even though the source code is not.
+  Whether this is true is especially significant if the work can be
+  linked without the Library, or if the work is itself a library.  The
+  threshold for this to be true is not precisely defined by law.
+
+    If such an object file uses only numerical parameters, data
+  structure layouts and accessors, and small macros and small inline
+  functions (ten lines or less in length), then the use of the object
+  file is unrestricted, regardless of whether it is legally a derivative
+  work.  (Executables containing this object code plus portions of the
+  Library will still fall under Section 6.)
+
+    Otherwise, if the work is a derivative of the Library, you may
+  distribute the object code for the work under the terms of Section 6.
+  Any executables containing that work also fall under Section 6,
+  whether or not they are linked directly with the Library itself.
+
+    6. As an exception to the Sections above, you may also combine or
+  link a "work that uses the Library" with the Library to produce a
+  work containing portions of the Library, and distribute that work
+  under terms of your choice, provided that the terms permit
+  modification of the work for the customer's own use and reverse
+  engineering for debugging such modifications.
+
+    You must give prominent notice with each copy of the work that the
+  Library is used in it and that the Library and its use are covered by
+  this License.  You must supply a copy of this License.  If the work
+  during execution displays copyright notices, you must include the
+  copyright notice for the Library among them, as well as a reference
+  directing the user to the copy of this License.  Also, you must do one
+  of these things:
+
+      a) Accompany the work with the complete corresponding
+      machine-readable source code for the Library including whatever
+      changes were used in the work (which must be distributed under
+      Sections 1 and 2 above); and, if the work is an executable linked
+      with the Library, with the complete machine-readable "work that
+      uses the Library", as object code and/or source code, so that the
+      user can modify the Library and then relink to produce a modified
+      executable containing the modified Library.  (It is understood
+      that the user who changes the contents of definitions files in the
+      Library will not necessarily be able to recompile the application
+      to use the modified definitions.)
+
+      b) Use a suitable shared library mechanism for linking with the
+      Library.  A suitable mechanism is one that (1) uses at run time a
+      copy of the library already present on the user's computer system,
+      rather than copying library functions into the executable, and (2)
+      will operate properly with a modified version of the library, if
+      the user installs one, as long as the modified version is
+      interface-compatible with the version that the work was made with.
+
+      c) Accompany the work with a written offer, valid for at
+      least three years, to give the same user the materials
+      specified in Subsection 6a, above, for a charge no more
+      than the cost of performing this distribution.
+
+      d) If distribution of the work is made by offering access to copy
+      from a designated place, offer equivalent access to copy the above
+      specified materials from the same place.
+
+      e) Verify that the user has already received a copy of these
+      materials or that you have already sent this user a copy.
+
+    For an executable, the required form of the "work that uses the
+  Library" must include any data and utility programs needed for
+  reproducing the executable from it.  However, as a special exception,
+  the materials to be distributed need not include anything that is
+  normally distributed (in either source or binary form) with the major
+  components (compiler, kernel, and so on) of the operating system on
+  which the executable runs, unless that component itself accompanies
+  the executable.
+
+    It may happen that this requirement contradicts the license
+  restrictions of other proprietary libraries that do not normally
+  accompany the operating system.  Such a contradiction means you cannot
+  use both them and the Library together in an executable that you
+  distribute.
+
+    7. You may place library facilities that are a work based on the
+  Library side-by-side in a single library together with other library
+  facilities not covered by this License, and distribute such a combined
+  library, provided that the separate distribution of the work based on
+  the Library and of the other library facilities is otherwise
+  permitted, and provided that you do these two things:
+
+      a) Accompany the combined library with a copy of the same work
+      based on the Library, uncombined with any other library
+      facilities.  This must be distributed under the terms of the
+      Sections above.
+
+      b) Give prominent notice with the combined library of the fact
+      that part of it is a work based on the Library, and explaining
+      where to find the accompanying uncombined form of the same work.
+
+    8. You may not copy, modify, sublicense, link with, or distribute
+  the Library except as expressly provided under this License.  Any
+  attempt otherwise to copy, modify, sublicense, link with, or
+  distribute the Library is void, and will automatically terminate your
+  rights under this License.  However, parties who have received copies,
+  or rights, from you under this License will not have their licenses
+  terminated so long as such parties remain in full compliance.
+
+    9. You are not required to accept this License, since you have not
+  signed it.  However, nothing else grants you permission to modify or
+  distribute the Library or its derivative works.  These actions are
+  prohibited by law if you do not accept this License.  Therefore, by
+  modifying or distributing the Library (or any work based on the
+  Library), you indicate your acceptance of this License to do so, and
+  all its terms and conditions for copying, distributing or modifying
+  the Library or works based on it.
+
+    10. Each time you redistribute the Library (or any work based on the
+  Library), the recipient automatically receives a license from the
+  original licensor to copy, distribute, link with or modify the Library
+  subject to these terms and conditions.  You may not impose any further
+  restrictions on the recipients' exercise of the rights granted herein.
+  You are not responsible for enforcing compliance by third parties with
+  this License.
+
+    11. If, as a consequence of a court judgment or allegation of patent
+  infringement or for any other reason (not limited to patent issues),
+  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
+  distribute so as to satisfy simultaneously your obligations under this
+  License and any other pertinent obligations, then as a consequence you
+  may not distribute the Library at all.  For example, if a patent
+  license would not permit royalty-free redistribution of the Library by
+  all those who receive copies directly or indirectly through you, then
+  the only way you could satisfy both it and this License would be to
+  refrain entirely from distribution of the Library.
+
+  If any portion of this section is held invalid or unenforceable under any
+  particular circumstance, the balance of the section is intended to apply,
+  and the section as a whole is intended to apply in other circumstances.
+
+  It is not the purpose of this section to induce you to infringe any
+  patents or other property right claims or to contest validity of any
+  such claims; this section has the sole purpose of protecting the
+  integrity of the free software distribution system which is
+  implemented by public license practices.  Many people have made
+  generous contributions to the wide range of software distributed
+  through that system in reliance on consistent application of that
+  system; it is up to the author/donor to decide if he or she is willing
+  to distribute software through any other system and a licensee cannot
+  impose that choice.
+
+  This section is intended to make thoroughly clear what is believed to
+  be a consequence of the rest of this License.
+
+    12. If the distribution and/or use of the Library is restricted in
+  certain countries either by patents or by copyrighted interfaces, the
+  original copyright holder who places the Library under this License may add
+  an explicit geographical distribution limitation excluding those countries,
+  so that distribution is permitted only in or among countries not thus
+  excluded.  In such case, this License incorporates the limitation as if
+  written in the body of this License.
+
+    13. The Free Software Foundation may publish revised and/or new
+  versions of the Lesser 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 Library
+  specifies a version number of this License which applies to it and
+  "any later version", you have the option of following the terms and
+  conditions either of that version or of any later version published by
+  the Free Software Foundation.  If the Library does not specify a
+  license version number, you may choose any version ever published by
+  the Free Software Foundation.
+
+    14. If you wish to incorporate parts of the Library into other free
+  programs whose distribution conditions are incompatible with these,
+  write to the author to ask for permission.  For software which is
+  copyrighted by the Free Software Foundation, write to the Free
+  Software Foundation; we sometimes make exceptions for this.  Our
+  decision will be guided by the two goals of preserving the free status
+  of all derivatives of our free software and of promoting the sharing
+  and reuse of software generally.
+
+            NO WARRANTY
+
+    15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+  WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+  OTHER PARTIES PROVIDE THE LIBRARY "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
+  LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+  THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+    16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+  WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+  AND/OR REDISTRIBUTE THE LIBRARY 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
+  LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+  SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+  DAMAGES.
+
+           END OF TERMS AND CONDITIONS
+
+             How to Apply These Terms to Your New Libraries
+
+    If you develop a new library, and you want it to be of the greatest
+  possible use to the public, we recommend making it free software that
+  everyone can redistribute and change.  You can do so by permitting
+  redistribution under these terms (or, alternatively, under the terms of the
+  ordinary General Public License).
+
+    To apply these terms, attach the following notices to the library.  It is
+  safest to attach them to the start of each source file to most effectively
+  convey 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 library's name and a brief idea of what it does.>
+      Copyright (C) <year>  <name of author>
+
+      This library is free software; you can redistribute it and/or
+      modify it under the terms of the GNU Lesser General Public
+      License as published by the Free Software Foundation; either
+      version 2.1 of the License, or (at your option) any later version.
+
+      This library 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
+      Lesser General Public License for more details.
+
+      You should have received a copy of the GNU Lesser General Public
+      License along with this library; if not, write to the Free Software
+      Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  Also add information on how to contact you by electronic and paper mail.
+
+  You should also get your employer (if you work as a programmer) or your
+  school, if any, to sign a "copyright disclaimer" for the library, if
+  necessary.  Here is a sample; alter the names:
+
+    Yoyodyne, Inc., hereby disclaims all copyright interest in the
+    library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+    <signature of Ty Coon>, 1 April 1990
+    Ty Coon, President of Vice
+
+  That's all there is to it!
diff --git a/MANIFEST.MF b/MANIFEST.MF
new file mode 100644
index 0000000..ba6fb81
--- /dev/null
+++ b/MANIFEST.MF
@@ -0,0 +1,2 @@
+Implementation-Title: JNA-POSIX
+Implementation-Version: 0.5
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..f6d9b54
--- /dev/null
+++ b/README.md
@@ -0,0 +1,9 @@
+Java Native Runtime - POSIX
+===========================
+
+[![Build Status](https://travis-ci.org/jnr/jnr-posix.svg?branch=master)](https://travis-ci.org/jnr/jnr-posix)
+[![Windows Build Status](https://ci.appveyor.com/api/projects/status/ywxa3ihwr6r8mlrs/branch/master?svg=true)](https://ci.appveyor.com/project/jnr/jnr-posix/branch/master)
+Overview
+--------
+
+jnr-posix is a lightweight cross-platform POSIX emulation layer for Java, written in Java and is part of the JNR project (http://github.com/jnr)
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..2167919
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,248 @@
+<?xml version="1.0" ?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>org.sonatype.oss</groupId>
+    <artifactId>oss-parent</artifactId>
+    <version>7</version>
+  </parent>
+
+  <groupId>com.github.jnr</groupId>
+  <artifactId>jnr-posix</artifactId>
+  <packaging>jar</packaging>
+  <version>3.1.21-SNAPSHOT</version>
+  <name>jnr-posix</name>
+  <description>
+    Common cross-project/cross-platform POSIX APIs
+  </description>
+
+  <issueManagement>
+    <system>JIRA</system>
+    <url>http://jira.codehaus.org/browse/JRUBY</url>
+  </issueManagement>
+
+  <scm>
+    <connection>scm:git:git@github.com:jnr/jnr-posix.git</connection>
+    <developerConnection>scm:git:git@github.com:jnr/jnr-posix.git</developerConnection>
+    <url>git@github.com:jnr/jnr-posix.git</url>
+  </scm>
+
+  <licenses>
+    <license>
+      <name>Eclipse Public License - v 2.0</name>
+      <url>https://www.eclipse.org/legal/epl-2.0/</url>
+      <distribution>repo</distribution>
+    </license>
+    <license>
+      <name>GNU General Public License Version 2</name>
+      <url>http://www.gnu.org/copyleft/gpl.html</url>
+      <distribution>repo</distribution>
+    </license>
+    <license>
+      <name>GNU Lesser General Public License Version 2.1</name>
+      <url>http://www.gnu.org/licenses/lgpl.html</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <developers>
+    <developer>
+      <id>enebo</id>
+      <name>Thomas E Enebo</name>
+      <email>tom.enebo@gmail.com</email>
+    </developer>
+    <developer>
+      <id>wmeissner</id>
+      <name>Wayne Meissner</name>
+      <email>wmeissner@gmail.com</email>
+    </developer>
+    <developer>
+      <id>headius</id>
+      <name>Charles Oliver Nutter</name>
+      <email>headius@headius.com</email>
+    </developer>
+  </developers>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <maven.compiler.source>8</maven.compiler.source>
+    <maven.compiler.target>8</maven.compiler.target>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.13.1</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.github.jnr</groupId>
+      <artifactId>jnr-ffi</artifactId>
+      <version>2.2.17</version>
+    </dependency>
+    <dependency>
+      <groupId>com.github.jnr</groupId>
+      <artifactId>jnr-constants</artifactId>
+      <version>0.10.4</version>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <extensions>
+      <extension>
+        <groupId>org.apache.maven.wagon</groupId>
+        <artifactId>wagon-webdav-jackrabbit</artifactId>
+        <version>1.0-beta-7</version>
+      </extension>
+    </extensions>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.felix</groupId>
+        <artifactId>maven-bundle-plugin</artifactId>
+        <version>2.3.7</version>
+        <configuration>
+          <instructions>
+            <Implementation-Title>JNA-POSIX</Implementation-Title>
+            <Implementation-Version>0.5</Implementation-Version>
+            <_nouses>true</_nouses>
+            <Import-Package>!sun.misc,*</Import-Package>
+          </instructions>
+        </configuration>
+        <executions>
+          <execution>
+            <id>bundle-manifest</id>
+            <phase>process-classes</phase>
+            <goals>
+              <goal>manifest</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>2.3.1</version>
+        <configuration>
+          <archive>
+            <manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
+            <manifestEntries>
+              <Automatic-Module-Name>org.jnrproject.posix</Automatic-Module-Name>
+            </manifestEntries>
+          </archive>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-source-plugin</artifactId>
+        <version>2.2.1</version>
+        <executions>
+          <execution>
+            <id>attach-sources</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <version>3.2.0</version>
+        <executions>
+          <execution>
+            <id>attach-javadocs</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.8.1</version>
+      </plugin>
+    </plugins>
+  </build>
+  <profiles>
+    <profile>
+      <id>non-windows-unit-tests</id>
+      <activation><os><family>!windows</family></os></activation>
+      <build>
+      <plugins>
+        <plugin>
+          <groupId>org.apache.maven.plugins</groupId>
+          <artifactId>maven-surefire-plugin</artifactId>
+          <version>2.18.1</version>
+          <configuration>
+            <forkCount>2</forkCount>
+            <reuseForks>false</reuseForks>
+            <includes>
+              <include>**/*Test.java</include>
+            </includes>
+            <excludes>
+              <exclude>**/windows/*Test.java</exclude>
+            </excludes>
+          </configuration>
+        </plugin>
+      </plugins>
+      </build>
+    </profile>
+    <profile>
+      <id>windows-unit-tests</id>
+      <activation><os><family>windows</family></os></activation>
+      <build>
+        <plugins>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-surefire-plugin</artifactId>
+            <version>2.18.1</version>
+            <configuration>
+              <forkCount>2</forkCount>
+              <reuseForks>false</reuseForks>
+            </configuration>
+          </plugin>
+        </plugins>
+      </build>
+    </profile>
+    <profile>
+      <id>java9</id>
+      <build>
+        <plugins>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-compiler-plugin</artifactId>
+            <executions>
+              <execution>
+                <id>default-compile</id>
+                <phase>compile</phase>
+                <goals><goal>compile</goal></goals>
+                <configuration>
+                  <includes>
+                    <include>jnr/posix/util/SunMiscSignal.java</include>
+                  </includes>
+                </configuration>
+              </execution>
+              <execution>
+                <id>java9-compile</id>
+                <phase>compile</phase>
+                <goals><goal>compile</goal></goals>
+                <configuration>
+                  <!-- Use -release compiler option rather than source/target if 9+ -->
+                  <release>${maven.compiler.target}</release>
+                  <excludes>
+                    <exclude>jnr/posix/util/SunMiscSignal.java</exclude>
+                  </excludes>
+                </configuration>
+              </execution>
+            </executions>
+          </plugin>
+        </plugins>
+      </build>
+      <activation>
+        <jdk>[9,)</jdk>
+      </activation>
+    </profile>
+  </profiles>
+</project>
diff --git a/src/main/java/jnr/posix/AbstractJavaFileStat.java b/src/main/java/jnr/posix/AbstractJavaFileStat.java
new file mode 100644
index 0000000..fae6bde
--- /dev/null
+++ b/src/main/java/jnr/posix/AbstractJavaFileStat.java
@@ -0,0 +1,133 @@
+package jnr.posix;
+
+public abstract class AbstractJavaFileStat implements FileStat {
+    protected final POSIXHandler handler;
+    protected final POSIX posix;
+
+    public AbstractJavaFileStat(POSIX posix, POSIXHandler handler) {
+        this.handler = handler;
+        this.posix = posix;
+    }
+
+    public boolean isBlockDev() {
+        handler.unimplementedError("block device detection");
+
+        return false;
+    }
+
+    /**
+     * Limitation: [see JRUBY-1516] We just pick more likely value.  This is a little scary.
+     */
+    public boolean isCharDev() {
+        return false;
+    }
+
+    public boolean isFifo() {
+        handler.unimplementedError("fifo file detection");
+
+        return false;
+    }
+
+    public boolean isNamedPipe() {
+        handler.unimplementedError("piped file detection");
+
+        return false;
+    }
+
+    public boolean isSetgid() {
+        handler.unimplementedError("setgid detection");
+
+        return false;
+    }
+
+    public boolean isSetuid() {
+        handler.unimplementedError("setuid detection");
+
+        return false;
+    }
+
+    public boolean isSocket() {
+        handler.unimplementedError("socket file type detection");
+
+        return false;
+    }
+
+    public boolean isSticky() {
+        handler.unimplementedError("sticky bit detection");
+
+        return false;
+    }
+
+    public int major(long dev) {
+        handler.unimplementedError("major device");
+
+        return -1;
+    }
+
+    public int minor(long dev) {
+        handler.unimplementedError("minor device");
+
+        return -1;
+    }
+
+    public int nlink() {
+        handler.unimplementedError("stat.nlink");
+
+        return -1;
+    }
+
+    public long rdev() {
+        handler.unimplementedError("stat.rdev");
+
+        return -1;
+    }
+
+    // Limitation: We have no pure-java way of getting uid. RubyZip needs this defined to work.
+    public int uid() {
+        return -1;
+    }
+
+    public long blocks() {
+        handler.unimplementedError("stat.st_blocks");
+
+        return -1;
+    }
+
+    public long blockSize() {
+        // Limitation: We cannot determine, so always return 4096 (better than blowing up)
+        return 4096;
+    }
+
+    public long dev() {
+        handler.unimplementedError("stat.st_dev");
+
+        return -1;
+    }
+
+    public String ftype() {
+        if (isFile()) {
+            return "file";
+        } else if (isDirectory()) {
+            return "directory";
+        }
+
+        return "unknown";
+    }
+
+    public int gid() {
+        handler.unimplementedError("stat.st_gid");
+
+        return -1;
+    }
+
+    public boolean groupMember(int gid) {
+        return posix.getgid() == gid || posix.getegid() == gid;
+    }
+
+    /**
+     *  Limitation: We have no pure-java way of getting inode.  webrick needs this defined to work.
+     */
+    public long ino() {
+        return 0;
+    }
+}
diff --git a/src/main/java/jnr/posix/AixFileStat.java b/src/main/java/jnr/posix/AixFileStat.java
new file mode 100644
index 0000000..c797373
--- /dev/null
+++ b/src/main/java/jnr/posix/AixFileStat.java
@@ -0,0 +1,150 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+import jnr.ffi.NativeType;
+import jnr.ffi.StructLayout;
+
+/**
+ * This corresponds with struct stat64x on AIX
+ */
+public final class AixFileStat extends BaseFileStat implements NanosecondFileStat {
+    private static final class Layout extends StructLayout {
+
+        private Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final Unsigned64 st_dev = new Unsigned64();
+        public final Signed64  st_ino = new Signed64();
+        public final Unsigned32  st_mode = new Unsigned32();
+        public final Signed16  st_nlink = new Signed16();
+        public final Unsigned16 st_flag = new Unsigned16();
+        public final Unsigned32 st_uid = new Unsigned32();
+        public final Unsigned32 st_gid = new Unsigned32();
+        public final Unsigned64  st_rdev = new Unsigned64();
+        public final Signed64  st_size = new Signed64();
+        public final Signed64 st_atime = new Signed64();
+        public final Signed32 st_atime_n = new Signed32();
+        public final Signed32 st_pad1 = new Signed32();
+
+        public final Signed64 st_mtime = new Signed64();
+        public final Signed32 st_mtime_n = new Signed32();
+        public final Signed32 st_pad2 = new Signed32();
+
+        public final Signed64 st_ctime = new Signed64();
+        public final Signed32 st_ctime_n = new Signed32();
+        public final Signed32 st_pad3 = new Signed32();
+
+        public final Unsigned64	st_blksize = new Unsigned64();
+        public final Unsigned64	st_blocks = new Unsigned64();
+        public final Signed32 st_vfstype = new Signed32();
+        
+        public final Unsigned32 st_vfs = new Unsigned32();
+        public final Unsigned32 st_type = new Unsigned32();
+        public final Unsigned32 st_gen = new Unsigned32();
+        public final Padding st_reserved = new Padding(NativeType.UINT, 11);
+        /* total size should be 176 bytes */
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public AixFileStat(NativePOSIX posix) {
+        super(posix, layout);
+    }
+
+    public long atime() {
+        return layout.st_atime.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctime.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return (int) layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return (int) layout.st_mode.get(memory) & 0xffff;
+    }
+
+    public long mtime() {
+        return layout.st_mtime.get(memory);
+    }
+
+    public int nlink() {
+        return (int) layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout.st_size.get(memory);
+    }
+
+    public int uid() {
+        return (int) layout.st_uid.get(memory);
+    }
+
+    @Override
+    public long aTimeNanoSecs() {
+        return layout.st_atime_n.get(memory);
+    }
+
+    @Override
+    public long cTimeNanoSecs() {
+        return layout.st_ctime_n.get(memory);
+    }
+
+    @Override
+    public long mTimeNanoSecs() {
+        return layout.st_mtime_n.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/AixFlock.java b/src/main/java/jnr/posix/AixFlock.java
new file mode 100644
index 0000000..75f8aa2
--- /dev/null
+++ b/src/main/java/jnr/posix/AixFlock.java
@@ -0,0 +1,55 @@
+package jnr.posix;
+
+public final class AixFlock extends Flock {
+    public final Signed16 l_type = new Signed16();
+    public final Signed16 l_whence = new Signed16();
+    public final Unsigned32 l_sysid = new Unsigned32();
+    public final Signed32 l_pid = new Signed32();
+    public final Signed32 l_vfs = new Signed32();
+    public final SignedLong l_start = new SignedLong();
+    public final SignedLong l_len = new SignedLong();
+
+    public AixFlock(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+
+    public void type(short type) {
+        this.l_type.set(type);
+    }
+
+    public void whence(short whence) {
+        this.l_whence.set(whence);
+    }
+
+    public void start(long start) {
+        this.l_start.set(start);
+    }
+
+    public void len(long len) {
+        this.l_len.set(len);
+    }
+
+    public void pid(int pid) {
+        this.l_pid.set(pid);
+    }
+
+    public short type() {
+        return this.l_type.get();
+    }
+
+    public short whence() {
+        return this.l_whence.get();
+    }
+
+    public long start() {
+        return this.l_start.get();
+    }
+
+    public long len() {
+        return this.l_len.get();
+    }
+
+    public int pid() {
+        return this.l_pid.get();
+    }
+}
diff --git a/src/main/java/jnr/posix/AixLibC.java b/src/main/java/jnr/posix/AixLibC.java
new file mode 100644
index 0000000..b84abe4
--- /dev/null
+++ b/src/main/java/jnr/posix/AixLibC.java
@@ -0,0 +1,38 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+public interface AixLibC extends UnixLibC {
+    public int stat64x(CharSequence path, AixFileStat stat);
+    public int fstat64x(int fd, AixFileStat stat);
+    public int lstat64x(CharSequence path, AixFileStat stat);
+}
diff --git a/src/main/java/jnr/posix/AixPOSIX.java b/src/main/java/jnr/posix/AixPOSIX.java
new file mode 100644
index 0000000..cb2d023
--- /dev/null
+++ b/src/main/java/jnr/posix/AixPOSIX.java
@@ -0,0 +1,149 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+import jnr.constants.platform.Sysconf;
+import jnr.constants.platform.Fcntl;
+import jnr.ffi.Memory;
+import jnr.ffi.Pointer;
+import jnr.ffi.mapper.FromNativeContext;
+import jnr.posix.util.MethodName;
+
+import java.io.FileDescriptor;
+import java.nio.ByteBuffer;
+import jnr.constants.platform.Confstr;
+import jnr.constants.platform.Pathconf;
+
+final class AixPOSIX extends BaseNativePOSIX {
+    // These should probably be put into jnr-constants instead eventually, but
+    // they're here for now as a one-off to work around AIX flock issues
+    private enum FlockFlags {
+        LOCK_SH(1),
+        LOCK_EX(2),
+        LOCK_NB(4),
+        LOCK_UN(8);
+        private final int value;
+        FlockFlags(int value) {
+            this.value = value;
+        }
+        public final int intValue() {
+            return value;
+        }
+    }
+
+    AixPOSIX(LibCProvider libc, POSIXHandler handler) {
+        super(libc, handler);
+    }
+
+    public FileStat allocateStat() { 
+        return new AixFileStat(this); 
+    }
+
+    public MsgHdr allocateMsgHdr() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return null;
+    }
+
+    public SocketMacros socketMacros() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return null;
+    }
+
+    public long sysconf(Sysconf name) {
+        return libc().sysconf(name);
+    }
+
+    public int confstr(Confstr name, ByteBuffer buf, int len) {
+        return libc().confstr(name, buf, len);
+    }
+
+    public int fpathconf(int fd, Pathconf name) {
+        return libc().fpathconf(fd, name);
+    }
+
+    public Times times() {
+        return NativeTimes.times(this);
+    }
+
+
+    public static final PointerConverter PASSWD = new PointerConverter() {
+        public Object fromNative(Object arg, FromNativeContext ctx) {
+            return arg != null ? new AixPasswd((Pointer) arg) : null;
+        }
+    };
+
+    public Pointer allocatePosixSpawnFileActions() {
+        return Memory.allocateDirect(getRuntime(), 4);
+    }
+
+    public Pointer allocatePosixSpawnattr() {
+        return Memory.allocateDirect(getRuntime(), 60);
+    }
+
+    // AIX flock lives in libbsd instead of libc.  AIX flock locks fully
+    // interact with fcntl locks, so we can implement flock in terms of fcntl,
+    // which is what we do here to avoid having to pull in that lib.
+    @Override
+    public int flock(int fd, int operation) {
+        int cmd = Fcntl.F_SETLKW.intValue();
+        short type = 0;
+
+        // Map the flock call flags to a fcntl flock type flag
+        if ((operation & FlockFlags.LOCK_SH.intValue()) != 0) {
+            type = (short)Fcntl.F_RDLCK.intValue();
+        } else if ((operation & FlockFlags.LOCK_EX.intValue()) != 0) {
+            type = (short)Fcntl.F_WRLCK.intValue();
+        } else if ((operation & FlockFlags.LOCK_UN.intValue()) != 0) {
+            type = (short)Fcntl.F_UNLCK.intValue();
+        }
+
+        // Switch to the fcntl non-blocking command
+        if ((operation & FlockFlags.LOCK_NB.intValue()) != 0) {
+            cmd = Fcntl.F_SETLK.intValue();
+        }
+
+        Flock flock = allocateFlock();
+        flock.type(type);
+        flock.whence((short)0);
+        flock.start(0);
+        flock.len(0);
+        return libc().fcntl(fd, cmd, flock);
+    }
+
+    @Override
+    public Timeval allocateTimeval() { return new AixTimeval(getRuntime()); }
+
+    // This isn't an override yet, because Flock would have to be implemented
+    // for all platforms, or at least with a DefaultNative implementation.  This
+    // is fine for now, because only AIX uses the flock structure
+    public Flock allocateFlock() { return new AixFlock(getRuntime()); }
+}
diff --git a/src/main/java/jnr/posix/AixPasswd.java b/src/main/java/jnr/posix/AixPasswd.java
new file mode 100644
index 0000000..b76a4b8
--- /dev/null
+++ b/src/main/java/jnr/posix/AixPasswd.java
@@ -0,0 +1,97 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+
+import jnr.ffi.StructLayout;
+
+public class AixPasswd extends NativePasswd implements Passwd {
+    private static final class Layout extends StructLayout {
+
+        private Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final UTF8StringRef pw_name = new UTF8StringRef();   // user name
+        public final UTF8StringRef pw_passwd = new UTF8StringRef(); // password (encrypted)
+        public final uid_t pw_uid = new uid_t();       // user id
+        public final gid_t pw_gid = new gid_t();       // user id
+        public final UTF8StringRef pw_gecos = new UTF8StringRef();  // login info
+        public final UTF8StringRef pw_dir = new UTF8StringRef();    // home directory
+        public final UTF8StringRef pw_shell = new UTF8StringRef();  // default shell
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    AixPasswd(jnr.ffi.Pointer memory) {
+        super(memory);
+    }
+
+    public String getAccessClass() {
+        return "unknown";
+    }
+
+    public String getGECOS() {
+        return layout.pw_gecos.get(memory);
+    }
+
+    public long getGID() {
+        return layout.pw_gid.get(memory);
+    }
+
+    public String getHome() {
+        return layout.pw_dir.get(memory);
+    }
+
+    public String getLoginName() {
+        return layout.pw_name.get(memory);
+    }
+
+    public int getPasswdChangeTime() {
+        return 0;
+    }
+
+    public String getPassword() {
+        return layout.pw_passwd.get(memory);
+    }
+
+    public String getShell() {
+        return layout.pw_shell.get(memory);
+    }
+
+    public long getUID() {
+        return layout.pw_uid.get(memory);
+    }
+
+    public int getExpire() {
+        return Integer.MAX_VALUE;
+    }
+}
diff --git a/src/main/java/jnr/posix/AixTimeval.java b/src/main/java/jnr/posix/AixTimeval.java
new file mode 100644
index 0000000..cbc0ece
--- /dev/null
+++ b/src/main/java/jnr/posix/AixTimeval.java
@@ -0,0 +1,32 @@
+package jnr.posix;
+
+public final class AixTimeval extends Timeval {
+    public final SignedLong tv_sec = new SignedLong();
+    public final Signed32 tv_usec = new Signed32();
+
+    public AixTimeval(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+
+    public void setTime(long[] timeval) {
+        assert timeval.length == 2;
+        tv_sec.set(timeval[0]);
+        tv_usec.set((int)timeval[1]);
+    }
+
+    public void sec(long sec) {
+        this.tv_sec.set(sec);
+    }
+
+    public void usec(long usec) {
+        this.tv_usec.set((int)usec);
+    }
+
+    public long sec() {
+        return tv_sec.get();
+    }
+
+    public long usec() {
+        return tv_usec.get();
+    }
+}
diff --git a/src/main/java/jnr/posix/BaseCmsgHdr.java b/src/main/java/jnr/posix/BaseCmsgHdr.java
new file mode 100644
index 0000000..c0148fc
--- /dev/null
+++ b/src/main/java/jnr/posix/BaseCmsgHdr.java
@@ -0,0 +1,50 @@
+package jnr.posix;
+
+import jnr.ffi.Memory;
+import jnr.ffi.Pointer;
+
+import java.nio.ByteBuffer;
+
+/**
+ * @author Bob McWhirter
+ */
+abstract class BaseCmsgHdr implements CmsgHdr {
+
+    protected final NativePOSIX posix;
+    final Pointer memory;
+
+    protected BaseCmsgHdr(NativePOSIX posix, Pointer memory) {
+        this.posix = posix;
+        this.memory = memory;
+    }
+
+    protected BaseCmsgHdr(NativePOSIX posix, Pointer memory, int totalLen) {
+        this.posix = posix;
+        this.memory = memory;
+        setLen( totalLen );
+    }
+
+    public void setData(ByteBuffer data) {
+        byte[] bytes = new byte[data.capacity() - data.position()];
+        data.get(bytes);
+        posix.socketMacros().CMSG_DATA(this.memory).put(0, bytes, 0, bytes.length);
+    }
+
+    public ByteBuffer getData() {
+        int dataLen =  getLen() - posix.socketMacros().CMSG_LEN(0);
+        if ( dataLen == 0 ) {
+            return null;
+        }
+        byte[] bytes = new byte[dataLen];
+
+        posix.socketMacros().CMSG_DATA(this.memory).get(0, bytes, 0, bytes.length);
+
+        ByteBuffer buf = ByteBuffer.allocate(bytes.length);
+        buf.put(bytes);
+        buf.flip();
+        return buf;
+    }
+
+    abstract void setLen(int len);
+
+}
diff --git a/src/main/java/jnr/posix/BaseFileStat.java b/src/main/java/jnr/posix/BaseFileStat.java
new file mode 100644
index 0000000..34fd10b
--- /dev/null
+++ b/src/main/java/jnr/posix/BaseFileStat.java
@@ -0,0 +1,193 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * 
+ *  
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+import jnr.ffi.Memory;
+import jnr.ffi.Pointer;
+import jnr.ffi.StructLayout;
+
+/**
+ *
+ */
+public abstract class BaseFileStat implements FileStat {
+    protected final POSIX posix;
+    protected final Pointer memory;
+
+    protected BaseFileStat(NativePOSIX posix, StructLayout layout) {
+        this.posix = posix;
+        this.memory = Memory.allocate(posix.getRuntime(), layout.size());
+    }
+    
+    public java.lang.String ftype() {
+        if (isFile()) {
+            return "file";
+        } else if (isDirectory()) {
+            return "directory";
+        } else if (isCharDev()) {
+            return "characterSpecial";
+        } else if (isBlockDev()) {
+            return "blockSpecial";
+        } else if (isFifo()) {
+            return "fifo";
+        } else if (isSymlink()) {
+            return "link";
+        } else if (isSocket()) {
+            return "socket";
+        } 
+          
+        return "unknown";
+    }
+
+    public boolean groupMember(int gid) {
+        if (posix.getgid() == gid || posix.getegid() == gid) {
+            return true;
+        }
+
+        // FIXME: Though not Posix, windows has different mechanism for this.
+        
+        return false;
+    }
+    
+    public boolean isBlockDev() {
+        return (mode() & S_IFMT) == S_IFBLK;
+    }
+    
+    public boolean isCharDev() {
+        return (mode() & S_IFMT) == S_IFCHR;
+    }
+
+    public boolean isDirectory() {
+        return (mode() & S_IFMT) == S_IFDIR;
+    }
+    
+    public boolean isEmpty() {
+        return st_size() == 0;
+    }
+
+    public boolean isExecutable() {
+        if (posix.geteuid() == 0) return (mode() & S_IXUGO) != 0;
+        if (isOwned()) return (mode() & S_IXUSR) != 0;
+        if (isGroupOwned()) return (mode() & S_IXGRP) != 0;
+        return (mode() & S_IXOTH) != 0;
+    }
+    
+    public boolean isExecutableReal() {
+        if (posix.getuid() == 0) return (mode() & S_IXUGO) != 0;
+        if (isROwned()) return (mode() & S_IXUSR) != 0;
+        if (groupMember(gid())) return (mode() & S_IXGRP) != 0;
+        return (mode() & S_IXOTH) != 0;
+    }
+    
+    public boolean isFile() {
+        return (mode() & S_IFMT) == S_IFREG;
+    }
+
+    public boolean isFifo() {
+        return (mode() & S_IFMT) == S_IFIFO;
+    }
+    
+    public boolean isGroupOwned() {
+        return groupMember(gid());
+    }
+
+    public boolean isIdentical(FileStat other) {
+        return dev() == other.dev() && ino() == other.ino(); 
+    }
+
+    public boolean isNamedPipe() {
+        return (mode() & S_IFIFO) != 0;
+    }
+    
+    public boolean isOwned() {
+        return posix.geteuid() == uid();
+    }
+    
+    public boolean isROwned() {
+        return posix.getuid() == uid();
+    }
+    
+    public boolean isReadable() {
+        if (posix.geteuid() == 0) return true;
+        if (isOwned()) return (mode() & S_IRUSR) != 0;
+        if (isGroupOwned()) return (mode() & S_IRGRP) != 0;
+        return (mode() & S_IROTH) != 0;
+    }
+    
+    public boolean isReadableReal() {
+        if (posix.getuid() == 0) return true;
+        if (isROwned()) return (mode() & S_IRUSR) != 0;
+        if (groupMember(gid())) return (mode() & S_IRGRP) != 0;
+        return (mode() & S_IROTH) != 0;
+    }
+    
+    public boolean isSetgid() {
+        return (mode() & S_ISGID) != 0;
+    }
+
+    public boolean isSetuid() {
+        return (mode() & S_ISUID) != 0;
+    }
+
+    public boolean isSocket() {
+        return (mode() & S_IFMT) == S_IFSOCK;
+    }
+    
+    public boolean isSticky() {
+        return (mode() & S_ISVTX) != 0;
+    }
+
+    public boolean isSymlink() {
+        return (mode() & S_IFMT) == S_IFLNK;
+    }
+
+    public boolean isWritable() {
+        if (posix.geteuid() == 0) return true;
+        if (isOwned()) return (mode() & S_IWUSR) != 0;
+        if (isGroupOwned()) return (mode() & S_IWGRP) != 0;
+        return (mode() & S_IWOTH) != 0;
+    }
+
+    public boolean isWritableReal() {
+        if (posix.getuid() == 0) return true;
+        if (isROwned()) return (mode() & S_IWUSR) != 0;
+        if (groupMember(gid())) return (mode() & S_IWGRP) != 0;
+        return (mode() & S_IWOTH) != 0;
+    }
+
+    public int major(long dev) {
+        return (int) (dev >> 24) & 0xff;
+    }
+    
+    public int minor(long dev) {
+        return (int) (dev & 0xffffff);
+    }
+}
diff --git a/src/main/java/jnr/posix/BaseIovec.java b/src/main/java/jnr/posix/BaseIovec.java
new file mode 100644
index 0000000..0273096
--- /dev/null
+++ b/src/main/java/jnr/posix/BaseIovec.java
@@ -0,0 +1,70 @@
+package jnr.posix;
+
+import jnr.ffi.Runtime;
+import jnr.ffi.Memory;
+import jnr.ffi.Pointer;
+import jnr.ffi.StructLayout;
+
+import java.nio.ByteBuffer;
+
+/**
+ * @author Bob McWhirter
+ */
+public class BaseIovec implements Iovec {
+
+
+    public static class Layout extends StructLayout {
+        protected Layout(Runtime runtime) {
+            super(runtime);
+        }
+
+        public final Pointer iov_base = new Pointer();
+        public final size_t iov_len = new size_t();
+    }
+
+    public static final Layout layout = new Layout(Runtime.getSystemRuntime());
+
+    private final NativePOSIX posix;
+    protected final Pointer memory;
+
+    public String toString(String indent) {
+        StringBuffer buf = new StringBuffer();
+        buf.append( indent ).append( "iovec {\n" );
+        buf.append(indent).append( "  iov_base=" ).append(layout.iov_base.get(this.memory)).append( ",\n" );
+        buf.append( indent ).append( "  iov_len=" ).append( layout.iov_len.get( this.memory ) ).append(",\n");
+        buf.append(indent).append( "}" );
+
+        return buf.toString();
+    }
+
+    protected BaseIovec(NativePOSIX posix) {
+        this.posix = posix;
+        this.memory = Memory.allocate(posix.getRuntime(), layout.size());
+    }
+
+    BaseIovec(NativePOSIX posix, Pointer memory) {
+        this.posix = posix;
+        this.memory = memory;
+    }
+
+    public ByteBuffer get() {
+        int len = getLen();
+        byte[] bytes = new byte[len];
+        layout.iov_base.get( this.memory ).get(0, bytes, 0, len );
+        return ByteBuffer.wrap( bytes );
+    }
+
+    public void set(ByteBuffer buf) {
+        int len = buf.remaining();
+        layout.iov_base.set( this.memory, Pointer.wrap( posix.getRuntime(), buf ) );
+        setLen(len);
+    }
+
+    protected void setLen(int len) {
+        layout.iov_len.set( this.memory, len );
+    }
+
+    protected int getLen() {
+        return (int) layout.iov_len.get( this.memory );
+    }
+}
diff --git a/src/main/java/jnr/posix/BaseMsgHdr.java b/src/main/java/jnr/posix/BaseMsgHdr.java
new file mode 100644
index 0000000..a5398b8
--- /dev/null
+++ b/src/main/java/jnr/posix/BaseMsgHdr.java
@@ -0,0 +1,150 @@
+package jnr.posix;
+
+import jnr.ffi.Pointer;
+import jnr.ffi.Runtime;
+import jnr.ffi.StructLayout;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author Bob McWhirter
+ */
+public abstract class BaseMsgHdr implements MsgHdr {
+
+    protected final NativePOSIX posix;
+    protected final Pointer memory;
+
+    protected BaseMsgHdr(NativePOSIX posix, StructLayout layout) {
+        this.posix = posix;
+        this.memory = posix.getRuntime().getMemoryManager().allocateTemporary(layout.size(), true);
+    }
+
+    public void setName(String name) {
+        if (name == null) {
+            setNamePointer(null);
+            setNameLen(0);
+            return;
+        }
+        byte[] nameBytes = name.getBytes(Charset.forName("US-ASCII"));
+        Pointer p = Runtime.getSystemRuntime().getMemoryManager().allocateTemporary(nameBytes.length, true);
+        p.put(0, nameBytes, 0, nameBytes.length);
+        setNamePointer(p);
+        setNameLen(nameBytes.length);
+    }
+
+    public String getName() {
+        Pointer ptr = getNamePointer();
+        if (ptr == null) {
+            return null;
+        }
+        return ptr.getString(0, getNameLen(), Charset.forName( "US-ASCII" ));
+    }
+
+    public CmsgHdr allocateControl(int dataLength) {
+        CmsgHdr[] controls = allocateControls(new int[]{dataLength});
+        return controls[0];
+    }
+
+    public CmsgHdr[] allocateControls(int[] dataLengths) {
+        CmsgHdr[] cmsgs = new CmsgHdr[dataLengths.length];
+
+        int totalSize = 0;
+        for (int i = 0; i < dataLengths.length; ++i) {
+            totalSize += posix.socketMacros().CMSG_SPACE(dataLengths[i]);
+        }
+
+        Pointer ptr = posix.getRuntime().getMemoryManager().allocateDirect(totalSize);
+
+        int offset = 0;
+        for (int i = 0; i < dataLengths.length; ++i) {
+            int eachSpace = posix.socketMacros().CMSG_SPACE(dataLengths[i]);
+            int len = posix.socketMacros().CMSG_LEN(dataLengths[i]);
+            CmsgHdr each = allocateCmsgHdrInternal(posix, ptr.slice(offset, eachSpace), len);
+            cmsgs[i] = each;
+            offset += eachSpace;
+        }
+
+        setControlPointer(ptr);
+        setControlLen(totalSize);
+
+        return cmsgs;
+    }
+
+    public CmsgHdr[] getControls() {
+        int len = getControlLen();
+        if (len == 0) {
+            return new CmsgHdr[0];
+        }
+
+        List<CmsgHdr> control = new ArrayList<CmsgHdr>();
+
+        int offset = 0;
+
+        Pointer controlPtr = getControlPointer();
+
+        while (offset < len) {
+            CmsgHdr each = allocateCmsgHdrInternal(posix, controlPtr.slice(offset), -1);
+            offset += posix.socketMacros().CMSG_SPACE(each.getLen());
+            control.add(each);
+        }
+
+        return control.toArray(new CmsgHdr[control.size()]);
+    }
+
+    public void setIov(ByteBuffer[] buffers) {
+        Pointer iov = Runtime.getSystemRuntime().getMemoryManager().allocateDirect(BaseIovec.layout.size() * buffers.length);
+
+        for (int i = 0; i < buffers.length; ++i) {
+            Pointer eachIovecPtr = iov.slice(BaseIovec.layout.size() * i);
+            BaseIovec eachIovec = new BaseIovec(posix, eachIovecPtr);
+            eachIovec.set(buffers[i]);
+        }
+
+        setIovPointer(iov);
+        setIovLen(buffers.length);
+    }
+
+    public ByteBuffer[] getIov() {
+        int len = getIovLen();
+
+        ByteBuffer[] buffers = new ByteBuffer[len];
+
+        Pointer iov = getIovPointer();
+
+        for (int i = 0; i < len; ++i) {
+            Pointer eachPtr = iov.slice(BaseIovec.layout.size() * i);
+            BaseIovec eachIov = new BaseIovec(posix, eachPtr);
+            buffers[i] = eachIov.get();
+        }
+
+        return buffers;
+    }
+
+    abstract void setNamePointer(Pointer name);
+
+    abstract Pointer getNamePointer();
+
+    abstract void setNameLen(int len);
+
+    abstract int getNameLen();
+
+    abstract void setIovPointer(Pointer iov);
+
+    abstract Pointer getIovPointer();
+
+    abstract int getIovLen();
+
+    abstract void setIovLen(int len);
+
+    abstract CmsgHdr allocateCmsgHdrInternal(NativePOSIX posix, Pointer pointer, int len);
+
+    abstract void setControlPointer(Pointer control);
+
+    abstract Pointer getControlPointer();
+
+    abstract void setControlLen(int len);
+
+}
diff --git a/src/main/java/jnr/posix/BaseNativePOSIX.java b/src/main/java/jnr/posix/BaseNativePOSIX.java
new file mode 100644
index 0000000..96ed7de
--- /dev/null
+++ b/src/main/java/jnr/posix/BaseNativePOSIX.java
@@ -0,0 +1,944 @@
+package jnr.posix;
+
+import jnr.constants.Constant;
+import jnr.constants.platform.Errno;
+import jnr.constants.platform.Fcntl;
+import jnr.constants.platform.Signal;
+import jnr.constants.platform.Sysconf;
+import jnr.ffi.*;
+import jnr.ffi.byref.NumberByReference;
+import jnr.ffi.mapper.FromNativeContext;
+import jnr.ffi.mapper.FromNativeConverter;
+import jnr.ffi.mapper.ToNativeContext;
+import jnr.ffi.mapper.ToNativeConverter;
+import jnr.posix.util.Java5ProcessMaker;
+import jnr.posix.util.MethodName;
+import jnr.posix.util.ProcessMaker;
+
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import jnr.constants.platform.Confstr;
+import jnr.constants.platform.Pathconf;
+import jnr.ffi.annotations.Out;
+
+public abstract class BaseNativePOSIX extends NativePOSIX implements POSIX {
+    private final LibC libc;
+    private final Crypt crypt;
+    
+    protected final POSIXHandler handler;
+    protected final JavaLibCHelper helper;
+    
+    protected final Map<Signal, SignalHandler> signalHandlers = new HashMap();
+    
+    protected BaseNativePOSIX(LibCProvider libcProvider, POSIXHandler handler) {
+        this.handler = handler;
+        this.libc = libcProvider.getLibC();
+        this.crypt = libcProvider.getCrypt();
+        this.helper = new JavaLibCHelper(handler);
+    }
+
+    public ProcessMaker newProcessMaker(String... command) {
+        return new Java5ProcessMaker(handler, command);
+    }
+
+    public ProcessMaker newProcessMaker() {
+        return new Java5ProcessMaker(handler);
+    }
+
+    public final LibC libc() {
+        return libc;
+    }
+
+    public final Crypt crypt() {
+        return crypt;
+    }
+
+    POSIXHandler handler() {
+        return handler;
+    }
+
+    protected <T> T unimplementedNull() {
+        handler().unimplementedError(MethodName.getCallerMethodName());
+        return null;
+    }
+
+    protected int unimplementedInt() {
+        handler().unimplementedError(MethodName.getCallerMethodName());
+        return -1;
+    }
+
+    public int chmod(String filename, int mode) {
+        return libc().chmod(filename, mode);
+    }
+
+    public int fchmod(int fd, int mode) {
+        return libc().fchmod(fd, mode);
+    }
+
+    public int chown(String filename, int user, int group) {
+        return libc().chown(filename, user, group);
+    }
+
+    public int fchown(int fd, int user, int group) {
+        return libc().fchown(fd, user, group);
+    }
+
+    public CharSequence crypt(CharSequence key, CharSequence salt) {
+        Crypt crypt = crypt();
+
+        if (crypt == null) {
+            return JavaLibCHelper.crypt(key, salt);
+        }
+
+        return crypt.crypt(key, salt);
+    }
+
+    public byte[] crypt(byte[] key, byte[] salt) {
+        Crypt crypt = crypt();
+
+        if (crypt == null) {
+            return JavaLibCHelper.crypt(key, salt);
+        }
+
+        Pointer ptr = crypt().crypt(key, salt);
+        if (ptr == null) return null;
+        int end = ptr.indexOf(0, (byte)0);
+        byte[] bytes = new byte[end + 1];
+        ptr.get(0, bytes, 0, end);
+
+        return bytes;
+    }
+
+    public int exec(String path, String... args) {
+        handler.unimplementedError("exec unimplemented");
+        return -1;
+    }
+    
+    public int exec(String path, String[] args, String[] envp) {
+        handler.unimplementedError("exec unimplemented");
+        return -1;
+    }
+    
+    public int execv(String path, String[] args) {
+        return libc().execv(path, args);
+    }
+    
+    public int execve(String path, String[] args, String[] env) {
+        return libc().execve(path, args, env);
+    }
+
+    public FileStat fstat(FileDescriptor fileDescriptor) {
+        FileStat stat = allocateStat();
+
+        if (fstat(fileDescriptor, stat) < 0) handler.error(Errno.valueOf(errno()), "fstat", "" + helper.getfd(fileDescriptor));
+        
+        return stat;
+    }
+
+    public FileStat fstat(int fd) {
+        FileStat stat = allocateStat();
+        if (fstat(fd, stat) < 0) handler.error(Errno.valueOf(errno()), "fstat", "" + fd);  
+        return stat;
+    }
+
+    
+    public int fstat(FileDescriptor fileDescriptor, FileStat stat) {
+        int fd = helper.getfd(fileDescriptor);
+        return libc().fstat(fd, stat);
+    }
+
+    public int fstat(int fd, FileStat stat) {
+        return libc().fstat(fd, stat);
+    }
+
+    public Pointer environ() {
+        return getRuntime().getMemoryManager().newPointer(libc().environ().get());
+    }
+
+    public String getenv(String envName) {
+        return libc().getenv(envName);
+    }
+
+    public int getegid() {
+        return libc().getegid();
+    }
+
+    public int geteuid() {
+        return libc().geteuid();
+    }
+
+    public int getgid() {
+        return libc().getgid();
+    }
+
+    public int getdtablesize() {
+        return libc().getdtablesize();
+    }
+
+    public String getlogin() {
+        return libc().getlogin();
+    }
+
+    public int getpgid() {
+        return libc().getpgid();
+    }
+
+    public int getpgrp() {
+        return libc().getpgrp();
+    }
+
+    public int getpid() {
+        return libc().getpid();
+    }
+
+    public int getppid() {
+        return libc().getppid();
+    }
+    
+    public Passwd getpwent() {
+        return libc().getpwent();
+    }
+
+    public Passwd getpwuid(int which) {
+        return libc().getpwuid(which);
+    }
+
+    public Passwd getpwnam(String which) {
+        return libc().getpwnam(which);
+    }
+
+    public Group getgrent() {
+        return libc().getgrent();
+    }
+    public Group getgrgid(int which) {
+        return libc().getgrgid(which);
+    }
+    public Group getgrnam(String which) {
+        return libc().getgrnam(which);
+    }
+
+    public int setpwent() {
+        return libc().setpwent();
+    }
+
+    public int endpwent() {
+        return libc().endpwent();
+    }
+
+    public int setgrent() {
+        return libc().setgrent();
+    }
+
+    public int endgrent() {
+        return libc().endgrent();
+    }
+
+    public int getuid() {
+        return libc().getuid();
+    }
+
+    public int getrlimit(int resource, RLimit rlim) {
+        return libc().getrlimit(resource, rlim);
+    }
+
+    public int getrlimit(int resource, Pointer rlim) {
+        return libc().getrlimit(resource, rlim);
+    }
+
+    public RLimit getrlimit(int resource) {
+        RLimit rlim = new DefaultNativeRLimit(getRuntime());
+
+        if (getrlimit(resource, rlim) < 0) handler.error(Errno.valueOf(errno()), "rlim");
+
+        return rlim;
+    }
+
+    public int setrlimit(int resource, RLimit rlim) {
+        return libc().setrlimit(resource, rlim);
+    }
+
+    public int setrlimit(int resource, Pointer rlim) {
+        return libc().setrlimit(resource, rlim);
+    }
+
+    public int setrlimit(int resource, long rlimCur, long rlimMax) {
+        RLimit rlim = new DefaultNativeRLimit(getRuntime());
+        rlim.init(rlimCur, rlimMax);
+
+        return libc().setrlimit(resource, rlim);
+    }
+
+    public int setegid(int egid) {
+        return libc().setegid(egid);
+    }
+
+    public int seteuid(int euid) {
+        return libc().seteuid(euid);
+    }
+
+    public int setgid(int gid) {
+        return libc().setgid(gid);
+    }
+    
+    public int getfd(FileDescriptor descriptor) {
+        return helper.getfd(descriptor);
+    }
+
+    public int getpgid(int pid) {
+        return libc().getpgid(pid);
+    }
+
+    public int setpgid(int pid, int pgid) {
+        return libc().setpgid(pid, pgid);
+    }
+
+    public int setpgrp(int pid, int pgrp) {
+        return libc().setpgrp(pid, pgrp);
+    }
+
+    public int setsid() {
+        return libc().setsid();
+    }
+
+    public int setuid(int uid) {
+        return libc().setuid(uid);
+    }
+
+    public int kill(int pid, int signal) {
+        return kill((long) pid, signal);
+    }
+
+    public int kill(long pid, int signal) {
+        return libc().kill(pid, signal);
+    }
+
+    public SignalHandler signal(Signal sig, final SignalHandler handler) {
+        synchronized (signalHandlers) {
+            SignalHandler old = signalHandlers.get(sig);
+
+            long result = libc().signal(sig.intValue(), new LibC.LibCSignalHandler() {
+                public void signal(int sig) {
+                    handler.handle(sig);
+                }
+            });
+
+            if (result != -1) {
+                signalHandlers.put(sig, handler);
+            }
+
+            return old;
+        }
+    }
+
+    public int raise(int sig) {
+        return libc().raise(sig);
+    }
+
+    public int lchmod(String filename, int mode) {
+        try {
+            return libc().lchmod(filename, mode);
+        } catch (UnsatisfiedLinkError ule) {
+            return unimplementedInt();
+        }
+    }
+
+    public int lchown(String filename, int user, int group) {
+        try {
+            return libc().lchown(filename, user, group);
+        } catch (UnsatisfiedLinkError ule) {
+            return unimplementedInt();
+        }
+    }
+
+    public int link(String oldpath, String newpath) {
+        return libc().link(oldpath, newpath);
+    }
+    
+    public FileStat lstat(String path) {
+        FileStat stat = allocateStat();
+        
+        if (lstat(path, stat) < 0) handler.error(Errno.valueOf(errno()), "lstat", path);
+        
+        return stat;
+    }
+    
+    public int lstat(String path, FileStat stat) {
+        return libc().lstat(path, stat);
+    }
+
+    public int mkdir(String path, int mode) {
+        int res = libc().mkdir(path, mode);
+        if (res < 0) {
+            int errno = errno();
+            handler.error(Errno.valueOf(errno), "mkdir", path);
+        }
+        return res;
+    }
+
+    public int rmdir(String path) {
+        int res = libc().rmdir(path);
+
+        if (res < 0) handler.error(Errno.valueOf(errno()), "rmdir", path);
+
+        return res;
+    }
+    
+    public int setenv(String envName, String envValue, int overwrite) {
+        return libc().setenv(envName, envValue, overwrite);
+    }
+
+    public FileStat stat(String path) {
+        FileStat stat = allocateStat();
+
+        if (stat(path, stat) < 0) handler.error(Errno.valueOf(errno()), "stat", path);
+        
+        return stat;
+    }
+
+    public int stat(String path, FileStat stat) {
+        return libc().stat(path, stat);
+    }
+
+    public int symlink(String oldpath, String newpath) {
+        return libc().symlink(oldpath, newpath);
+    }
+    
+    public String readlink(String oldpath) throws IOException {
+        // TODO: this should not be hardcoded to 1024 bytes
+        ByteBuffer buffer = ByteBuffer.allocate(1024);
+        int result = libc().readlink(oldpath, buffer, buffer.capacity());
+        
+        if (result == -1) return null;
+        
+        buffer.position(0);
+        buffer.limit(result);
+        return Charset.defaultCharset().decode(buffer).toString();
+    }
+
+    public int readlink(CharSequence path, byte[] buf, int bufsize) {
+        return libc().readlink(path, buf, bufsize);
+    }
+
+    public int readlink(CharSequence path, ByteBuffer buf, int bufsize) {
+        return libc().readlink(path, buf, bufsize);
+    }
+
+    public int readlink(CharSequence path, Pointer bufPtr, int bufsize) {
+        return libc().readlink(path, bufPtr, bufsize);
+    }
+
+    public int unsetenv(String envName) {
+        return libc().unsetenv(envName);
+    }
+    
+    public int umask(int mask) {
+        return libc().umask(mask);
+    }
+    
+    public int utimes(String path, long[] atimeval, long[] mtimeval) {
+        Timeval[] times = null;
+        if (atimeval != null && mtimeval != null) {
+            times = Struct.arrayOf(getRuntime(), DefaultNativeTimeval.class, 2);
+            times[0].setTime(atimeval);
+            times[1].setTime(mtimeval);
+        }
+        return libc().utimes(path, times);
+    }
+
+    public int utimes(String path, Pointer times) {
+        return libc().utimes(path, times);
+    }
+
+    public int futimes(int fd, long[] atimeval, long[] mtimeval) {
+        Timeval[] times = null;
+        if (atimeval != null && mtimeval != null) {
+            times = Struct.arrayOf(getRuntime(), DefaultNativeTimeval.class, 2);
+            times[0].setTime(atimeval);
+            times[1].setTime(mtimeval);
+        }
+        return libc().futimes(fd, times);
+    }
+
+    public int lutimes(String path, long[] atimeval, long[] mtimeval) {
+        Timeval[] times = null;
+        if (atimeval != null && mtimeval != null) {
+            times = Struct.arrayOf(getRuntime(), DefaultNativeTimeval.class, 2);
+            times[0].setTime(atimeval);
+            times[1].setTime(mtimeval);
+        }
+        return libc().lutimes(path, times);
+    }
+
+    public int utimensat(int dirfd, String path, long[] atimespec, long[] mtimespec, int flag) {
+        Timespec[] times = null;
+        if (atimespec != null && mtimespec != null) {
+            times = Struct.arrayOf(getRuntime(), DefaultNativeTimespec.class, 2);
+            times[0].setTime(atimespec);
+            times[1].setTime(mtimespec);
+        }
+        return libc().utimensat(dirfd, path, times, flag);
+    }
+
+    public int utimensat(int dirfd, String path, Pointer times, int flag) {
+        return libc().utimensat(dirfd, path, times, flag);
+    }
+
+    public int futimens(int fd, long[] atimespec, long[] mtimespec) {
+        Timespec[] times = null;
+        if (atimespec != null && mtimespec != null) {
+            times = Struct.arrayOf(getRuntime(), DefaultNativeTimespec.class, 2);
+            times[0].setTime(atimespec);
+            times[1].setTime(mtimespec);
+        }
+        return libc().futimens(fd, times);
+    }
+
+    public int futimens(int fd, Pointer times) {
+        return libc().futimens(fd, times);
+    }
+
+    public int fork() {
+        return libc().fork();
+    }
+    
+    public int waitpid(int pid, int[] status, int flags) {
+        return waitpid((long)pid, status, flags);
+    }
+
+    public int waitpid(long pid, int[] status, int flags) {
+        return libc().waitpid(pid, status, flags);
+    }
+    
+    public int wait(int[] status) {
+        return libc().wait(status);
+    }
+    
+    public int getpriority(int which, int who) {
+        return libc().getpriority(which, who);
+    }
+    
+    public int setpriority(int which, int who, int prio) {
+        return libc().setpriority(which, who, prio);
+    }
+
+    public boolean isatty(FileDescriptor fd) {
+       return isatty(helper.getfd(fd)) != 0;
+    }
+
+    public int isatty(int fd) {
+        return libc().isatty(fd);
+    }
+
+    public int errno() {
+        return LastError.getLastError(getRuntime());
+    }
+
+    public void errno(int value) {
+        LastError.setLastError(getRuntime(), value);
+    }
+    
+    public int chdir(String path) {
+        return libc().chdir(path);
+    }
+
+    public boolean isNative() {
+        return true;
+    }
+
+    public long posix_spawnp(String path, Collection<? extends SpawnFileAction> fileActions,
+                             CharSequence[] argv, CharSequence[] envp) {
+        return posix_spawnp(path, fileActions, null, argv, envp);
+    }
+
+    public long posix_spawnp(String path, Collection<? extends SpawnFileAction> fileActions,
+                            Collection<? extends CharSequence> argv, Collection<? extends CharSequence> envp) {
+        return posix_spawnp(path, fileActions, null, argv, envp);
+    }
+    
+    public long posix_spawnp(String path, Collection<? extends SpawnFileAction> fileActions,
+                             Collection<? extends SpawnAttribute> spawnAttributes,
+                             Collection<? extends CharSequence> argv, Collection<? extends CharSequence> envp) {
+        
+        CharSequence[] nativeArgv = new CharSequence[argv.size()];
+        argv.toArray(nativeArgv);
+
+        CharSequence[] nativeEnv = new CharSequence[envp.size()];
+        envp.toArray(nativeEnv);
+
+        return posix_spawnp(path, fileActions, spawnAttributes, nativeArgv, nativeEnv);
+    }
+
+    public long posix_spawnp(String path, Collection<? extends SpawnFileAction> fileActions,
+                             Collection<? extends SpawnAttribute> spawnAttributes,
+                             CharSequence[] argv, CharSequence[] envp) {
+//        AbstractNumberReference<? extends Number> pid = getRuntime().findType(TypeAlias.pid_t).size() == 4
+//            ? new IntByReference(-1) : new LongLongByReference(-1);
+        NumberByReference pid = new NumberByReference(TypeAlias.pid_t);
+        Pointer nativeFileActions = fileActions != null && !fileActions.isEmpty() ? nativeFileActions(fileActions) : null;
+        Pointer nativeSpawnAttributes = spawnAttributes != null && !spawnAttributes.isEmpty() ? nativeSpawnAttributes(spawnAttributes) : null;
+        long result;
+
+        try {
+            result = ((UnixLibC) libc()).posix_spawnp(pid, path, nativeFileActions, nativeSpawnAttributes, argv, envp);
+        } finally {
+            if (nativeFileActions != null) ((UnixLibC) libc()).posix_spawn_file_actions_destroy(nativeFileActions);
+            if (nativeSpawnAttributes != null) ((UnixLibC) libc()).posix_spawnattr_destroy(nativeSpawnAttributes);
+        }
+
+        if (result != 0) return -1; // result will be errno, but we can't indicate error because we return pid
+        return pid.longValue();
+    }
+    
+    public int flock(int fd, int mode) {
+        return libc().flock(fd, mode);
+    }
+
+    public int dup(int fd) {
+        return libc().dup(fd);
+    }
+
+    public int dup2(int oldFd, int newFd) {
+        return libc().dup2(oldFd, newFd);
+    }
+
+    public int fcntlInt(int fd, Fcntl fcntl, int arg) {
+        return fcntl(fd, fcntl, arg);
+    }
+
+    public int fcntl(int fd, Fcntl fcntl) {
+        return libc().fcntl(fd, fcntl.intValue());
+    }
+
+    public int fcntl(int fd, Fcntl fcntl, int arg) {
+        return libc().fcntl(fd, fcntl.intValue(), arg);
+    }
+
+    @Deprecated
+    public int fcntl(int fd, Fcntl fcntl, int... args) {
+        if (args != null) {
+            if (args.length == 1) {
+                return fcntl(fd, fcntl, args[0]);
+            }
+        }
+        throw new IllegalArgumentException("fcntl with variadic int args is unsupported");
+    }
+
+    public int access(CharSequence path, int amode) {
+        return libc().access(path, amode);
+    }
+
+    public int close(int fd) {
+        return libc().close(fd);
+    }
+
+    private Pointer nativeFileActions(Collection<? extends SpawnFileAction> fileActions) {
+        Pointer nativeFileActions = allocatePosixSpawnFileActions();
+        ((UnixLibC) libc()).posix_spawn_file_actions_init(nativeFileActions);
+        for (SpawnFileAction action : fileActions) {
+            action.act(this, nativeFileActions);
+        }
+
+        return nativeFileActions;
+    }
+
+    private Pointer nativeSpawnAttributes(Collection<? extends SpawnAttribute> spawnAttributes) {
+        Pointer nativeSpawnAttributes = allocatePosixSpawnattr();
+        ((UnixLibC) libc()).posix_spawnattr_init(nativeSpawnAttributes);
+        for (SpawnAttribute action : spawnAttributes) {
+            action.set(this, nativeSpawnAttributes);
+        }
+
+        return nativeSpawnAttributes;
+    }
+
+    public abstract FileStat allocateStat();
+
+    public long sysconf(Sysconf name) {
+        switch (name) {
+            case _SC_CLK_TCK:
+                return JavaTimes.HZ;
+
+            default:
+                errno(Errno.EOPNOTSUPP.intValue());
+                return -1;
+        }
+    }
+
+    public int confstr(Confstr name, ByteBuffer buf, int len) {
+        errno(Errno.EOPNOTSUPP.intValue());
+        return -1;
+    }
+
+    public int fpathconf(int fd, Pathconf name) {
+        errno(Errno.EOPNOTSUPP.intValue());
+        return -1;
+    }
+
+    public Times times() {
+        return new JavaTimes();
+    }
+
+    public int unlink(CharSequence path) {
+        return libc().unlink(path);
+    }
+
+    public int open(CharSequence path, int flags, int perm) {
+        return libc().open(path, flags, perm);
+    }
+
+    public long read(int fd, byte[] buf, long n) {
+        return libc().read(fd, buf, n);
+    }
+    public long write(int fd, byte[] buf, long n) {
+        return libc().write(fd, buf, n);
+    }
+    public long read(int fd, ByteBuffer buf, long n) {
+        return libc().read(fd, buf, n);
+    }
+    public long write(int fd, ByteBuffer buf, long n) {
+        return libc().write(fd, buf, n);
+    }
+    public long pread(int fd, byte[] buf, long n, long offset) {
+        return libc().pread(fd, buf, n, offset);
+    }
+    public long pwrite(int fd, byte[] buf, long n, long offset) {
+        return libc().pwrite(fd, buf, n, offset);
+    }
+    public long pread(int fd, ByteBuffer buf, long n, long offset) {
+        return libc().pread(fd, buf, n, offset);
+    }
+    public long pwrite(int fd, ByteBuffer buf, long n, long offset) {
+        return libc().pwrite(fd, buf, n, offset);
+    }
+
+    public int read(int fd, byte[] buf, int n) {
+        return libc().read(fd, buf, n);
+    }
+    public int write(int fd, byte[] buf, int n) {
+        return libc().write(fd, buf, n);
+    }
+    public int read(int fd, ByteBuffer buf, int n) {
+        return libc().read(fd, buf, n);
+    }
+    public int write(int fd, ByteBuffer buf, int n) {
+        return libc().write(fd, buf, n);
+    }
+    public int pread(int fd, byte[] buf, int n, int offset) {
+        return libc().pread(fd, buf, n, offset);
+    }
+    public int pwrite(int fd, byte[] buf, int n, int offset) {
+        return libc().pwrite(fd, buf, n, offset);
+    }
+    public int pread(int fd, ByteBuffer buf, int n, int offset) {
+        return libc().pread(fd, buf, n, offset);
+    }
+    public int pwrite(int fd, ByteBuffer buf, int n, int offset) {
+        return libc().pwrite(fd, buf, n, offset);
+    }
+
+    public int lseek(int fd, long offset, int whence) {
+        return (int) libc().lseek(fd, offset, whence);
+    }
+
+    public long lseekLong(int fd, long offset, int whence) {
+        return libc().lseek(fd, offset, whence);
+    }
+
+    public int pipe(int[] fds) {
+        return libc().pipe(fds);
+    }
+
+    public int socketpair(int domain, int type, int protocol, int[] fds) {
+        return libc().socketpair(domain, type, protocol, fds);
+    }
+
+    public int sendmsg(int socket, MsgHdr message, int flags) {
+        return libc().sendmsg( socket, message, flags );
+    }
+
+    public int recvmsg(int socket, MsgHdr message, int flags) {
+        return libc().recvmsg(socket, message, flags);
+    }
+
+    public int truncate(CharSequence path, long length) {
+        return libc().truncate(path, length);
+    }
+
+    public int ftruncate(int fd, long offset) {
+        return libc().ftruncate(fd, offset);
+    }
+
+    public int rename(CharSequence oldName, CharSequence newName) {
+        return libc().rename(oldName, newName);
+    }
+
+    public String gethostname() {
+        ByteBuffer buffer = ByteBuffer.allocate(256);
+        int result;
+        try {
+            result = libc().gethostname(buffer, buffer.capacity() - 1);
+        } catch (java.lang.UnsatisfiedLinkError e) {
+            result = -1;
+        }
+        if (result == -1) return helper.gethostname();
+        buffer.position(0);
+        while (buffer.hasRemaining() && buffer.get() != 0);
+        buffer.limit(buffer.position() - 1);
+        buffer.position(0);
+        return Charset.forName("US-ASCII").decode(buffer).toString();
+    }
+
+    public String getcwd() {
+        byte[] cwd = new byte[1024];
+        long result = libc().getcwd(cwd, 1024);
+        if (result == -1) return null;
+        int len = 0;
+        for (; len < 1024; len++) if (cwd[len] == 0) break;
+        return new String(cwd, 0, len);
+    }
+
+    public int fsync(int fd) {
+        return libc().fsync(fd);
+    }
+
+    public int fdatasync(int fd) {
+        return libc().fdatasync(fd);
+    }
+
+    public static abstract class PointerConverter implements FromNativeConverter {
+        public Class nativeType() {
+            return Pointer.class;
+        }
+    }
+    
+    public static final PointerConverter GROUP = new PointerConverter() {
+        public Object fromNative(Object arg, FromNativeContext ctx) {
+            return arg != null ? new DefaultNativeGroup((Pointer) arg) : null;
+        }
+    };
+
+    public static final ToNativeConverter<FileStat, Pointer> FileStatConverter = new ToNativeConverter<FileStat, Pointer>() {
+
+        public Pointer toNative(FileStat value, ToNativeContext context) {
+            if (value instanceof BaseFileStat) {
+                return ((BaseFileStat) value).memory;
+
+            } else if (value instanceof Struct) {
+                return Struct.getMemory((Struct) value);
+
+            } else if (value == null) {
+                return null;
+            }
+
+            throw new IllegalArgumentException("instance of " + value.getClass() + " is not a struct");
+        }
+
+        public Class<Pointer> nativeType() {
+            return Pointer.class;
+        }
+
+    };
+
+    public static final ToNativeConverter<NativeTimes, Pointer> TimesConverter = new ToNativeConverter<NativeTimes, Pointer>() {
+
+        public Pointer toNative(NativeTimes value, ToNativeContext context) {
+            return value.memory;
+        }
+
+        public Class<Pointer> nativeType() {
+            return Pointer.class;
+        }
+    };
+
+    public static final ToNativeConverter<Constant, Integer> ConstantConverter = new ToNativeConverter<Constant, Integer>() {
+
+        public Integer toNative(Constant value, ToNativeContext context) {
+            return value.intValue();
+        }
+
+        public Class<Integer> nativeType() {
+            return Integer.class;
+        }
+    };
+
+    public static final ToNativeConverter<MsgHdr, Pointer> MsgHdrConverter = new ToNativeConverter<MsgHdr, Pointer>() {
+        public Pointer toNative(MsgHdr value, ToNativeContext context) {
+            if ( value instanceof BaseMsgHdr ) {
+                return ((BaseMsgHdr) value).memory;
+            } else if ( value instanceof Struct ) {
+                return Struct.getMemory((Struct) value);
+            } else if ( value == null ) {
+                return null;
+            }
+
+            throw new IllegalArgumentException("instance of " + value.getClass() + " is not a struct");
+        }
+
+        public Class<Pointer> nativeType() {
+            return Pointer.class;
+        }
+    };
+
+    public int mkfifo(String filename, int mode) {
+        return ((UnixLibC) libc()).mkfifo(filename, mode);
+    }
+
+    public int daemon(int nochdir, int noclose) {
+        return libc().daemon(nochdir, noclose);
+    }
+
+    @Override
+    public long[] getgroups() {
+        final int size = getgroups(0, null);
+        final int[] groups = new int[size];
+        final long[] castGroups = new long[size];
+
+        final int actualSize = getgroups(size, groups);
+
+        if (actualSize == -1) {
+            return null;
+        }
+
+        for (int i = 0; i < actualSize; i++) {
+            castGroups[i] = groups[i] & 0xFFFFFFFFL;
+        }
+
+        if (actualSize < size) {
+            return Arrays.copyOfRange(castGroups, 0, actualSize);
+        }
+
+        return castGroups;
+    }
+
+    @Override
+    public int getgroups(int size, int[] groups) {
+        return libc().getgroups(size, groups);
+    }
+
+    @Override
+    public String nl_langinfo(int item) {
+        return libc().nl_langinfo(item);
+    }
+
+    @Override
+    public String setlocale(int category, String locale) {
+        return libc().setlocale(category, locale);
+    }
+
+    @Override
+    public String strerror(int code) {
+        return libc().strerror(code);
+    }
+
+    @Override
+    public Timeval allocateTimeval() { return new DefaultNativeTimeval(getRuntime()); }
+
+    @Override
+    public int gettimeofday(Timeval tv) { return libc().gettimeofday(tv, 0); }
+}
diff --git a/src/main/java/jnr/posix/CheckedPOSIX.java b/src/main/java/jnr/posix/CheckedPOSIX.java
new file mode 100644
index 0000000..887929d
--- /dev/null
+++ b/src/main/java/jnr/posix/CheckedPOSIX.java
@@ -0,0 +1,644 @@
+package jnr.posix;
+
+import jnr.constants.platform.Fcntl;
+import jnr.constants.platform.Signal;
+import jnr.constants.platform.Sysconf;
+import jnr.ffi.Pointer;
+import jnr.posix.util.MethodName;
+import jnr.posix.util.ProcessMaker;
+
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import jnr.constants.platform.Confstr;
+import jnr.constants.platform.Pathconf;
+
+final class CheckedPOSIX implements POSIX {
+    private final POSIX posix;
+    private final POSIXHandler handler;
+    
+    CheckedPOSIX(POSIX posix, POSIXHandler handler) {
+        this.posix = posix;
+        this.handler = handler;
+    }
+
+    private <T> T unimplementedNull() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return null;
+    }
+
+    private int unimplementedInt() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return -1;
+    }
+
+    private boolean unimplementedBool() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return false;
+    }
+
+    private String unimplementedString() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return null;
+    }
+
+    public ProcessMaker newProcessMaker(String... command) {
+        try { return posix.newProcessMaker(command); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public ProcessMaker newProcessMaker() {
+        try { return posix.newProcessMaker(); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public FileStat allocateStat() {
+        try { return posix.allocateStat(); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public MsgHdr allocateMsgHdr() {
+        try { return posix.allocateMsgHdr(); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public int chdir(String path) {
+        try { return posix.chdir(path); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int chmod(String filename, int mode) {
+        try { return posix.chmod(filename, mode); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int fchmod(int fd, int mode) {
+        try { return posix.fchmod(fd, mode); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int chown(String filename, int user, int group) {
+        try { return posix.chown(filename, user, group); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public CharSequence crypt(CharSequence key, CharSequence salt) {
+        try { return posix.crypt(key, salt); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public byte[] crypt(byte[] key, byte[] salt) {
+        try { return posix.crypt(key, salt); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public int fchown(int fd, int user, int group) {
+        try { return posix.fchown(fd, user, group); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int endgrent() {
+        try { return posix.endgrent(); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int endpwent() {
+        try { return posix.endpwent(); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int errno() {
+        return posix.errno();
+    }
+
+    public void errno(int value) {
+        posix.errno(value);
+    }
+
+    public int exec(String path, String... args) {
+        try { return posix.exec(path, args); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int exec(String path, String[] args, String[] envp) {
+        try { return posix.exec(path, args, envp); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int execv(String path, String[] argv) {
+        try { return posix.execv(path, argv); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int execve(String path, String[] argv, String[] envp) {
+        try { return posix.execve(path, argv, envp); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int fork() {
+        try { return posix.fork(); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public FileStat fstat(int fd) {
+        try { return posix.fstat(fd); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public int fstat(int fd, FileStat stat) {
+        try { return posix.fstat(fd, stat); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public FileStat fstat(FileDescriptor descriptor) {
+        try { return posix.fstat(descriptor); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public int fstat(FileDescriptor descriptor, FileStat stat) {
+        try { return posix.fstat(descriptor, stat); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int getegid() {
+        try { return posix.getegid(); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int geteuid() {
+        try { return posix.geteuid(); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int getgid() {
+        try { return posix.getgid(); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int getdtablesize() {
+        try { return posix.getdtablesize(); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public Group getgrent() {
+        try { return posix.getgrent(); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public Group getgrgid(int which) {
+        try { return posix.getgrgid(which); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public Group getgrnam(String which) {
+        try { return posix.getgrnam(which); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public String getlogin() {
+        try { return posix.getlogin(); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public int getpgid() {
+        try { return posix.getpgid(); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int getpgid(int pid) {
+        try { return posix.getpgid(pid); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int getpgrp() {
+        try { return posix.getpgrp(); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int getpid() {
+        try { return posix.getpid(); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int getppid() {
+        try { return posix.getppid(); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int getpriority(int which, int who) {
+        try { return posix.getpriority(which, who); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public Passwd getpwent() {
+        try { return posix.getpwent(); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public Passwd getpwnam(String which) {
+        try { return posix.getpwnam(which); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public Passwd getpwuid(int which) {
+        try { return posix.getpwuid(which); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public int getuid() {
+        try { return posix.getuid(); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int getrlimit(int resource, RLimit rlim) {
+        try { return posix.getrlimit(resource, rlim); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int getrlimit(int resource, Pointer rlim) {
+        try { return posix.getrlimit(resource, rlim); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public RLimit getrlimit(int resource) {
+        try { return posix.getrlimit(resource); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public int setrlimit(int resource, RLimit rlim) {
+        try { return posix.setrlimit(resource, rlim); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int setrlimit(int resource, Pointer rlim) {
+        try { return posix.setrlimit(resource, rlim); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int setrlimit(int resource, long rlimCur, long rlimMax) {
+        try { return posix.setrlimit(resource, rlimCur, rlimMax); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public boolean isatty(FileDescriptor descriptor) {
+        try { return posix.isatty(descriptor); } catch (UnsatisfiedLinkError ule) { return unimplementedBool(); }
+    }
+
+    public int isatty(int descriptor) {
+        try { return posix.isatty(descriptor); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int kill(int pid, int signal) {
+        return kill((long) pid, signal);
+    }
+
+    public int kill(long pid, int signal) {
+        try { return posix.kill(pid, signal); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public SignalHandler signal(Signal sig, SignalHandler handler) {
+        try { return posix.signal(sig, handler); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public int raise(int sig) {
+        try { return posix.raise(sig); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int lchmod(String filename, int mode) {
+        try { return posix.lchmod(filename, mode); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int lchown(String filename, int user, int group) {
+        try { return posix.lchown(filename, user, group); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int link(String oldpath, String newpath) {
+        try { return posix.link(oldpath, newpath); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public FileStat lstat(String path) {
+        try { return posix.lstat(path); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public int lstat(String path, FileStat stat) {
+        try { return posix.lstat(path, stat); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int mkdir(String path, int mode) {
+        try { return posix.mkdir(path, mode); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public String readlink(String path) throws IOException {
+        try { return posix.readlink(path); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public int readlink(CharSequence path, byte[] buf, int bufsize) {
+        try { return posix.readlink(path, buf, bufsize); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int readlink(CharSequence path, ByteBuffer buf, int bufsize) {
+        try { return posix.readlink(path, buf, bufsize); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int readlink(CharSequence path, Pointer bufPtr, int bufsize) {
+        try { return posix.readlink(path, bufPtr, bufsize); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int rmdir(String path) {
+        try { return posix.rmdir(path); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int setegid(int egid) {
+        try { return posix.setegid(egid); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int seteuid(int euid) {
+        try { return posix.seteuid(euid); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int setgid(int gid) {
+        try { return posix.setgid(gid); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int setgrent() {
+        try { return posix.setgrent(); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int setpgid(int pid, int pgid) {
+        try { return posix.setpgid(pid, pgid); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int setpgrp(int pid, int pgrp) {
+        try { return posix.setpgrp(pid, pgrp); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int setpriority(int which, int who, int prio) {
+        try { return posix.setpriority(which, who, prio); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int setpwent() {
+        try { return posix.setpwent(); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int setsid() {
+        try { return posix.setsid(); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int setuid(int uid) {
+        try { return posix.setuid(uid); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public FileStat stat(String path) {
+        try { return posix.stat(path); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public int stat(String path, FileStat stat) {
+        try { return posix.stat(path, stat); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int symlink(String oldpath, String newpath) {
+        try { return posix.symlink(oldpath, newpath); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int umask(int mask) {
+        try { return posix.umask(mask); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int utimes(String path, long[] atimeval, long[] mtimeval) {
+        try { return posix.utimes(path, atimeval, mtimeval); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int utimes(String path, Pointer times) {
+        try { return posix.utimes(path, times); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int futimes(int fd, long[] atimeval, long[] mtimeval) {
+        try { return posix.futimes(fd, atimeval, mtimeval); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int lutimes(String path, long[] atimeval, long[] mtimeval) {
+        try { return posix.lutimes(path, atimeval, mtimeval); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int utimensat(int dirfd, String path, long[] atimespec, long[] mtimespec, int flag) {
+        try { return posix.utimensat(dirfd, path, atimespec, mtimespec, flag); } catch (UnsatisfiedLinkError ule) {
+            return unimplementedInt(); }
+    }
+
+    public int utimensat(int dirfd, String path, Pointer times, int flag) {
+        try { return posix.utimensat(dirfd, path, times, flag); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int futimens(int fd, long[] atimespec, long[] mtimespec) {
+        try { return posix.futimens(fd, atimespec, mtimespec); } catch (UnsatisfiedLinkError ule) {
+            return unimplementedInt(); }
+    }
+
+    public int futimens(int fd, Pointer times) {
+        try { return posix.futimens(fd, times); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int wait(int[] status) {
+        try { return posix.wait(status); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int waitpid(int pid, int[] status, int flags) {
+        return waitpid((long)pid, status, flags);
+    }
+
+    public int waitpid(long pid, int[] status, int flags) {
+        try { return posix.waitpid(pid, status, flags); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public boolean isNative() {
+        return posix.isNative();
+    }
+
+    public LibC libc() {
+        return posix.libc();
+    }
+
+    public Pointer environ() {
+        try { return posix.environ(); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public String getenv(String envName) {
+        try { return posix.getenv(envName); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    public int setenv(String envName, String envValue, int overwrite) {
+        try { return posix.setenv(envName, envValue, overwrite); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int unsetenv(String envName) {
+        try { return posix.unsetenv(envName); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public long posix_spawnp(String path, Collection<? extends SpawnFileAction> fileActions, Collection<? extends CharSequence> argv, Collection<? extends CharSequence> envp) {
+        try { return posix.posix_spawnp(path, fileActions, argv, envp); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public long posix_spawnp(String path, Collection<? extends SpawnFileAction> fileActions,
+                             Collection<? extends SpawnAttribute> spawnAttributes,
+                             Collection<? extends CharSequence> argv, Collection<? extends CharSequence> envp) {
+        try { return posix.posix_spawnp(path, fileActions, spawnAttributes, argv, envp); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+
+    public long sysconf(Sysconf name) {
+        try { return posix.sysconf(name); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int confstr(Confstr name, ByteBuffer buf, int len) {
+        try { return posix.confstr(name, buf, len); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int fpathconf(int fd, Pathconf name) {
+        try { return posix.fpathconf(fd, name); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public Times times() {
+        try { return posix.times(); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+    
+    public int flock(int fd, int mode) {
+        return posix.flock(fd, mode);
+    }
+
+    public int dup(int fd) {
+        try { return posix.dup(fd); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int dup2(int oldFd, int newFd) {
+        try { return posix.dup2(oldFd, newFd); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int fcntlInt(int fd, Fcntl fcntlConst, int arg) {
+        try { return posix.fcntlInt(fd, fcntlConst, arg); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int fcntl(int fd, Fcntl fcntlConst) {
+        try { return posix.fcntl(fd, fcntlConst); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int fcntl(int fd, Fcntl fcntlConst, int arg) {
+        try { return posix.fcntl(fd, fcntlConst, arg); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    @Deprecated
+    public int fcntl(int fd, Fcntl fcntlConst, int... arg) {
+        try { return posix.fcntl(fd, fcntlConst); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int access(CharSequence path, int amode) {
+        try { return posix.access(path, amode); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int close(int fd) {
+        try { return posix.close(fd); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int unlink(CharSequence path) {
+        try { return posix.unlink(path); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int open(CharSequence path, int flags, int perm) {
+        try { return posix.open(path, flags, perm); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public long read(int fd, byte[] buf, long n) {
+        try { return posix.read(fd, buf, n); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+    public long write(int fd, byte[] buf, long n) {
+        try { return posix.write(fd, buf, n); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+    public long read(int fd, ByteBuffer buf, long n) {
+        try { return posix.read(fd, buf, n); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+    public long write(int fd, ByteBuffer buf, long n) {
+        try { return posix.write(fd, buf, n); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+    public long pread(int fd, byte[] buf, long n, long offset) {
+        try { return posix.pread(fd, buf, n, offset); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+    public long pwrite(int fd, byte[] buf, long n, long offset) {
+        try { return posix.pwrite(fd, buf, n, offset); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+    public long pread(int fd, ByteBuffer buf, long n, long offset) {
+        try { return posix.pread(fd, buf, n, offset); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+    public long pwrite(int fd, ByteBuffer buf, long n, long offset) {
+        try { return posix.pwrite(fd, buf, n, offset); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int read(int fd, byte[] buf, int n) {
+        try { return posix.read(fd, buf, n); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+    public int write(int fd, byte[] buf, int n) {
+        try { return posix.write(fd, buf, n); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+    public int read(int fd, ByteBuffer buf, int n) {
+        try { return posix.read(fd, buf, n); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+    public int write(int fd, ByteBuffer buf, int n) {
+        try { return posix.write(fd, buf, n); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+    public int pread(int fd, byte[] buf, int n, int offset) {
+        try { return posix.pread(fd, buf, n, offset); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+    public int pwrite(int fd, byte[] buf, int n, int offset) {
+        try { return posix.pwrite(fd, buf, n, offset); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+    public int pread(int fd, ByteBuffer buf, int n, int offset) {
+        try { return posix.pread(fd, buf, n, offset); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+    public int pwrite(int fd, ByteBuffer buf, int n, int offset) {
+        try { return posix.pwrite(fd, buf, n, offset); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int lseek(int fd, long offset, int whence) {
+        try { return posix.lseek(fd, offset, whence); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public long lseekLong(int fd, long offset, int whence) {
+        try { return posix.lseekLong(fd, offset, whence); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int pipe(int[] fds) {
+        try {return posix.pipe(fds); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int socketpair(int domain, int type, int protocol, int[] fds) {
+        try {return posix.socketpair(domain, type, protocol, fds); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int sendmsg(int socket, MsgHdr message, int flags) {
+        try {return posix.sendmsg(socket, message, flags); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int recvmsg(int socket, MsgHdr message, int flags) {
+        try {return posix.recvmsg(socket, message, flags); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int truncate(CharSequence path, long length) {
+        try { return posix.truncate(path, length); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int ftruncate(int fd, long offset) {
+        try {return posix.ftruncate(fd, offset); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int rename(CharSequence oldName, CharSequence newName) {
+        try {return posix.rename(oldName, newName); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public String getcwd() {
+        try {return posix.getcwd(); } catch (UnsatisfiedLinkError ule) { return unimplementedString(); }
+    }
+
+    public int fsync(int fd) {
+        try {return posix.fsync(fd); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int fdatasync(int fd) {
+        try {return posix.fsync(fd); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int mkfifo(String path, int mode) {
+        try {return posix.mkfifo(path, mode); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public int daemon(int nochdir, int noclose) {
+        try {return posix.daemon(nochdir, noclose); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public long[] getgroups() {
+        try {return posix.getgroups(); } catch (UnsatisfiedLinkError ule) { return null; }
+    }
+
+    public int getgroups(int size, int[] groups) {
+        try {return posix.getgroups(size, groups); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public String nl_langinfo(int item) {
+        try {return posix.nl_langinfo(item); } catch (UnsatisfiedLinkError ule) { return unimplementedString(); }
+    }
+
+    public String setlocale(int category, String locale) {
+        try {return posix.setlocale(category, locale); } catch (UnsatisfiedLinkError ule) { return unimplementedString(); }
+    }
+
+    @Override
+    public String strerror(int code) {
+        try {return posix.strerror(code); } catch (UnsatisfiedLinkError ule) { return unimplementedString(); }
+    }
+
+    @Override
+    public Timeval allocateTimeval() {
+        try {return posix.allocateTimeval(); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+
+    @Override
+    public int gettimeofday(Timeval tv) {
+        try {return posix.gettimeofday(tv); } catch (UnsatisfiedLinkError ule) { return unimplementedInt(); }
+    }
+
+    public String gethostname() {
+        try {return posix.gethostname(); } catch (UnsatisfiedLinkError ule) { return unimplementedNull(); }
+    }
+}
diff --git a/src/main/java/jnr/posix/CmsgHdr.java b/src/main/java/jnr/posix/CmsgHdr.java
new file mode 100644
index 0000000..a20fab8
--- /dev/null
+++ b/src/main/java/jnr/posix/CmsgHdr.java
@@ -0,0 +1,24 @@
+package jnr.posix;
+
+import java.nio.ByteBuffer;
+
+/**
+ * @author Bob McWhirter
+ */
+public interface CmsgHdr {
+
+    void setLevel(int level);
+
+    int getLevel();
+
+    void setType(int type);
+
+    int getType();
+
+    void setData(ByteBuffer data);
+
+    ByteBuffer getData();
+
+    int getLen();
+
+}
diff --git a/src/main/java/jnr/posix/Crypt.java b/src/main/java/jnr/posix/Crypt.java
new file mode 100644
index 0000000..34ef981
--- /dev/null
+++ b/src/main/java/jnr/posix/Crypt.java
@@ -0,0 +1,8 @@
+package jnr.posix;
+
+import jnr.ffi.Pointer;
+
+public interface Crypt {
+    CharSequence crypt(CharSequence key, CharSequence salt);
+    Pointer crypt(byte[] key, byte[] salt);
+}
diff --git a/src/main/java/jnr/posix/DefaultNativeGroup.java b/src/main/java/jnr/posix/DefaultNativeGroup.java
new file mode 100644
index 0000000..8bc6914
--- /dev/null
+++ b/src/main/java/jnr/posix/DefaultNativeGroup.java
@@ -0,0 +1,86 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+
+package jnr.posix;
+
+import jnr.ffi.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The default native group layout.
+ * 
+ * <p>
+ * This implementation should work on Solaris, Linux and MacOS.
+ * </p>
+ */
+public final class DefaultNativeGroup extends NativeGroup implements Group {
+    static final class Layout extends StructLayout {
+        public Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final UTF8StringRef gr_name = new UTF8StringRef();   // name
+        public final UTF8StringRef gr_passwd = new UTF8StringRef(); // group password (encrypted)
+        public final Signed32 gr_gid = new Signed32();       // group id
+        public final Pointer gr_mem = new Pointer();
+    }
+
+    static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+    private final Pointer memory;
+
+    DefaultNativeGroup(jnr.ffi.Pointer memory) {
+        super(memory.getRuntime(), layout);
+        this.memory = memory;
+    }
+
+    public java.lang.String getName() {
+        return layout.gr_name.get(memory);
+    }
+
+    public java.lang.String getPassword() {
+        return layout.gr_passwd.get(memory);
+    }
+
+    public long getGID() {
+        return layout.gr_gid.get(memory);
+    }
+
+    public java.lang.String[] getMembers() {
+        List<java.lang.String> lst = new ArrayList<java.lang.String>();
+
+        jnr.ffi.Pointer ptr = layout.gr_mem.get(memory);
+        Pointer member;
+        int ptrSize = runtime.addressSize();
+        for (int i = 0; (member = ptr.getPointer(i)) != null; i += ptrSize) {
+            lst.add(member.getString(0));
+        }
+
+        return lst.toArray(new java.lang.String[lst.size()]);
+    }
+
+}
diff --git a/src/main/java/jnr/posix/DefaultNativeRLimit.java b/src/main/java/jnr/posix/DefaultNativeRLimit.java
new file mode 100644
index 0000000..f285572
--- /dev/null
+++ b/src/main/java/jnr/posix/DefaultNativeRLimit.java
@@ -0,0 +1,26 @@
+package jnr.posix;
+
+public class DefaultNativeRLimit extends RLimit {
+    public final UnsignedLong rlim_cur = new UnsignedLong();
+    public final UnsignedLong rlim_max = new UnsignedLong();
+
+    protected DefaultNativeRLimit(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+
+    @Override
+    public void init(long rlimCur, long rlimMax) {
+        rlim_cur.set(rlimCur);
+        rlim_max.set(rlimMax);
+    }
+
+    @Override
+    public long rlimCur() {
+        return rlim_cur.get();
+    }
+
+    @Override
+    public long rlimMax() {
+        return rlim_max.get();
+    }
+}
diff --git a/src/main/java/jnr/posix/DefaultNativeTimespec.java b/src/main/java/jnr/posix/DefaultNativeTimespec.java
new file mode 100644
index 0000000..dda3b77
--- /dev/null
+++ b/src/main/java/jnr/posix/DefaultNativeTimespec.java
@@ -0,0 +1,32 @@
+package jnr.posix;
+
+public final class DefaultNativeTimespec extends Timespec {
+    public final SignedLong tv_sec = new SignedLong();
+    public final SignedLong tv_nsec = new SignedLong();
+
+    public DefaultNativeTimespec(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+
+    public void setTime(long[] timespec) {
+        assert timespec.length == 2;
+        tv_sec.set(timespec[0]);
+        tv_nsec.set(timespec[1]);
+    }
+
+    public void sec(long sec) {
+        this.tv_sec.set(sec);
+    }
+
+    public void nsec(long usec) {
+        this.tv_nsec.set(usec);
+    }
+
+    public long sec() {
+        return tv_sec.get();
+    }
+
+    public long nsec() {
+        return tv_nsec.get();
+    }
+}
diff --git a/src/main/java/jnr/posix/DefaultNativeTimeval.java b/src/main/java/jnr/posix/DefaultNativeTimeval.java
new file mode 100644
index 0000000..0cb2aa6
--- /dev/null
+++ b/src/main/java/jnr/posix/DefaultNativeTimeval.java
@@ -0,0 +1,32 @@
+package jnr.posix;
+
+public final class DefaultNativeTimeval extends Timeval {
+    public final SignedLong tv_sec = new SignedLong();
+    public final SignedLong tv_usec = new SignedLong();
+
+    public DefaultNativeTimeval(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+
+    public void setTime(long[] timeval) {
+        assert timeval.length == 2;
+        tv_sec.set(timeval[0]);
+        tv_usec.set(timeval[1]);
+    }
+
+    public void sec(long sec) {
+        this.tv_sec.set(sec);
+    }
+
+    public void usec(long usec) {
+        this.tv_usec.set(usec);
+    }
+
+    public long sec() {
+        return tv_sec.get();
+    }
+
+    public long usec() {
+        return tv_usec.get();
+    }
+}
diff --git a/src/main/java/jnr/posix/DragonFlyFileStat.java b/src/main/java/jnr/posix/DragonFlyFileStat.java
new file mode 100644
index 0000000..89dba35
--- /dev/null
+++ b/src/main/java/jnr/posix/DragonFlyFileStat.java
@@ -0,0 +1,141 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+
+public final class DragonFlyFileStat extends BaseFileStat implements NanosecondFileStat {
+    private static final class Layout extends StructLayout {
+
+        private Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final class time_t extends SignedLong {}
+        public final class dev_t extends Unsigned32 {}
+
+        public final Signed64    st_ino = new Signed64();
+        public final Signed32    st_nlink = new Signed32();
+        public final dev_t       st_dev = new dev_t();
+        public final Unsigned16  st_mode = new Unsigned16();
+        public final Unsigned16  st_padding1 = new Unsigned16();
+        public final Signed32    st_uid = new Signed32();
+        public final Signed32    st_gid = new Signed32();
+        public final dev_t       st_rdev = new dev_t();
+        public final time_t      st_atim = new time_t();
+        public final time_t      st_atimnsec = new time_t();
+        public final time_t      st_mtim = new time_t();
+        public final time_t      st_mtimnsec = new time_t();
+        public final time_t      st_ctim = new time_t();
+        public final time_t      st_ctimnsec = new time_t();
+        public final Signed32    st_size = new Signed32();
+        public final Signed32    st_blocks = new Signed32();
+        public final Signed32    st_blksize = new Signed32();
+        public final Signed32    st_flags = new Signed32();
+        public final Signed32    st_gen = new Signed32();
+        public final Signed32    st_lspare = new Signed32();
+        public final Signed64    st_qspare1 = new Signed64();
+        public final Signed64    st_qspare2 = new Signed64();
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public DragonFlyFileStat(NativePOSIX posix) {
+        super(posix, layout);
+    }
+
+    public long atime() {
+        return layout.st_atim.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctim.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return layout.st_mode.get(memory) & 0xffff;
+    }
+
+    public long mtime() {
+        return layout.st_mtim.get(memory);
+    }
+
+    public int nlink() {
+        return layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout.st_size.get(memory);
+    }
+
+    public int uid() {
+        return layout.st_uid.get(memory);
+    }
+
+    @Override
+    public long aTimeNanoSecs() {
+        return layout.st_atimnsec.get(memory);
+    }
+
+    @Override
+    public long cTimeNanoSecs() {
+        return layout.st_ctimnsec.get(memory);
+    }
+
+    @Override
+    public long mTimeNanoSecs() {
+        return layout.st_mtimnsec.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/DragonFlyPOSIX.java b/src/main/java/jnr/posix/DragonFlyPOSIX.java
new file mode 100644
index 0000000..a8ba316
--- /dev/null
+++ b/src/main/java/jnr/posix/DragonFlyPOSIX.java
@@ -0,0 +1,92 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+import java.nio.ByteBuffer;
+import jnr.constants.platform.Confstr;
+import jnr.constants.platform.Pathconf;
+import jnr.constants.platform.Sysconf;
+import jnr.ffi.Memory;
+import jnr.ffi.mapper.FromNativeContext;
+import jnr.ffi.Pointer;
+import jnr.posix.util.MethodName;
+
+final class DragonFlyPOSIX extends BaseNativePOSIX {
+    DragonFlyPOSIX(LibCProvider libc, POSIXHandler handler) {
+        super(libc, handler);
+    }
+
+    public FileStat allocateStat() {
+        return new DragonFlyFileStat(this);
+    }
+
+    public MsgHdr allocateMsgHdr() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return null;
+    }
+
+    public SocketMacros socketMacros() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return null;
+    }
+
+    public long sysconf(Sysconf name) {
+        return libc().sysconf(name);
+    }
+
+    public int confstr(Confstr name, ByteBuffer buf, int len) {
+        return libc().confstr(name, buf, len);
+    }
+
+    public int fpathconf(int fd, Pathconf name) {
+        return libc().fpathconf(fd, name);
+    }
+
+    public Times times() {
+        return NativeTimes.times(this);
+    }
+
+
+    public static final PointerConverter PASSWD = new PointerConverter() {
+        public Object fromNative(Object arg, FromNativeContext ctx) {
+            return arg != null ? new DragonFlyPasswd((Pointer) arg) : null;
+        }
+    };
+
+    public Pointer allocatePosixSpawnFileActions() {
+        return Memory.allocateDirect(getRuntime(), 8);
+    }
+
+    public Pointer allocatePosixSpawnattr() {
+        return Memory.allocateDirect(getRuntime(), 8);
+    }
+}
diff --git a/src/main/java/jnr/posix/DragonFlyPasswd.java b/src/main/java/jnr/posix/DragonFlyPasswd.java
new file mode 100644
index 0000000..8876b70
--- /dev/null
+++ b/src/main/java/jnr/posix/DragonFlyPasswd.java
@@ -0,0 +1,101 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+
+import jnr.ffi.StructLayout;
+
+public class DragonFlyPasswd extends NativePasswd implements Passwd {
+    private static final class Layout extends StructLayout {
+
+        private Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final UTF8StringRef pw_name = new UTF8StringRef();   // user name
+        public final UTF8StringRef pw_passwd = new UTF8StringRef(); // password (encrypted)
+        public final Signed32 pw_uid = new Signed32();       // user id
+        public final Signed32 pw_gid = new Signed32();       // user id
+        public final SignedLong pw_change = new SignedLong();// password change time
+        public final UTF8StringRef pw_class = new UTF8StringRef();  // user access class
+        public final UTF8StringRef pw_gecos = new UTF8StringRef();  // login info
+        public final UTF8StringRef pw_dir = new UTF8StringRef();    // home directory
+        public final UTF8StringRef pw_shell = new UTF8StringRef();  // default shell
+        public final SignedLong pw_expire = new SignedLong();    // account expiration
+        public final Signed32 pw_fields = new Signed32();    // internal: fields filled in
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    DragonFlyPasswd(jnr.ffi.Pointer memory) {
+        super(memory);
+    }
+
+    public java.lang.String getAccessClass() {
+        return layout.pw_class.get(memory);
+    }
+
+    public java.lang.String getGECOS() {
+        return layout.pw_gecos.get(memory);
+    }
+
+    public long getGID() {
+        return layout.pw_gid.get(memory);
+    }
+
+    public java.lang.String getHome() {
+        return layout.pw_dir.get(memory);
+    }
+
+    public java.lang.String getLoginName() {
+        return layout.pw_name.get(memory);
+    }
+
+    public int getPasswdChangeTime() {
+        return layout.pw_change.intValue(memory);
+    }
+
+    public java.lang.String getPassword() {
+        return layout.pw_passwd.get(memory);
+    }
+
+    public java.lang.String getShell() {
+        return layout.pw_shell.get(memory);
+    }
+
+    public long getUID() {
+        return layout.pw_uid.get(memory);
+    }
+
+    public int getExpire() {
+        return layout.pw_expire.intValue(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/FileStat.java b/src/main/java/jnr/posix/FileStat.java
new file mode 100644
index 0000000..992bae7
--- /dev/null
+++ b/src/main/java/jnr/posix/FileStat.java
@@ -0,0 +1,73 @@
+package jnr.posix;
+
+public interface FileStat {
+    public static final int S_IFIFO = 0010000;  // named pipe (fifo)
+    public static final int S_IFCHR = 0020000;  // character special
+    public static final int S_IFDIR = 0040000;  // directory
+    public static final int S_IFBLK = 0060000;  // block special
+    public static final int S_IFREG = 0100000;  // regular
+    public static final int S_IFLNK = 0120000;  // symbolic link
+    public static final int S_IFSOCK = 0140000; // socket
+    public static final int S_IFMT = 0170000;   // file mask for type checks
+    public static final int S_ISUID = 0004000;  // set user id on execution
+    public static final int S_ISGID = 0002000;  // set group id on execution
+    public static final int S_ISVTX = 0001000;  // save swapped text even after use
+    public static final int S_IRUSR = 0000400;  // read permission, owner
+    public static final int S_IWUSR = 0000200;  // write permission, owner
+    public static final int S_IXUSR = 0000100;  // execute/search permission, owner
+    public static final int S_IRGRP = 0000040;  // read permission, group
+    public static final int S_IWGRP = 0000020;  // write permission, group
+    public static final int S_IXGRP = 0000010;  // execute/search permission, group
+    public static final int S_IROTH = 0000004;  // read permission, other
+    public static final int S_IWOTH = 0000002;  // write permission, other
+    public static final int S_IXOTH = 0000001;  // execute permission, other
+    
+    public static final int ALL_READ = S_IRUSR | S_IRGRP | S_IROTH;
+    public static final int ALL_WRITE = S_IWUSR | S_IWGRP | S_IWOTH;
+    public static final int S_IXUGO = S_IXUSR | S_IXGRP | S_IXOTH;
+
+    public long atime();
+    public long blocks();
+    public long blockSize();
+    public long ctime();
+    public long dev();
+    public String ftype();
+    public int gid();
+    public boolean groupMember(int gid);
+    public long ino();
+    public boolean isBlockDev();
+    public boolean isCharDev();
+    public boolean isDirectory();
+    public boolean isEmpty();
+    public boolean isExecutable();
+    public boolean isExecutableReal();
+    public boolean isFifo();
+    public boolean isFile();
+    public boolean isGroupOwned();
+    public boolean isIdentical(FileStat other);
+    public boolean isNamedPipe();
+    public boolean isOwned();
+    public boolean isROwned();
+    public boolean isReadable();
+    public boolean isReadableReal();
+    public boolean isWritable();
+    public boolean isWritableReal();
+    public boolean isSetgid();
+    public boolean isSetuid();
+    public boolean isSocket();
+    public boolean isSticky();
+    public boolean isSymlink();
+    public int major(long dev);
+    public int minor(long dev);
+    public int mode();
+    public long mtime();
+    public int nlink();
+    public long rdev();
+    /**
+     * Note: Name 'st_size' since Structure has a 'size' method already
+     *
+     * @return size of the stat structure
+     */
+    public long st_size();
+    public int uid();
+}
diff --git a/src/main/java/jnr/posix/FileTime.java b/src/main/java/jnr/posix/FileTime.java
new file mode 100644
index 0000000..ddd402f
--- /dev/null
+++ b/src/main/java/jnr/posix/FileTime.java
@@ -0,0 +1,12 @@
+package jnr.posix;
+
+import jnr.ffi.Struct;
+
+public class FileTime extends Struct {
+    public final Unsigned32 dwLowDateTime = new Unsigned32();
+    public final Unsigned32 dwHighDateTime = new Unsigned32();
+    
+    FileTime(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+}
diff --git a/src/main/java/jnr/posix/Flock.java b/src/main/java/jnr/posix/Flock.java
new file mode 100644
index 0000000..47855d8
--- /dev/null
+++ b/src/main/java/jnr/posix/Flock.java
@@ -0,0 +1,20 @@
+package jnr.posix;
+
+import jnr.ffi.Struct;
+
+abstract public class Flock extends Struct {
+    public Flock(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+    public abstract void type(short type);
+    public abstract void whence(short whence);
+    public abstract void start(long start);
+    public abstract void len(long len);
+    public abstract void pid(int pid);
+
+    public abstract short type();
+    public abstract short whence();
+    public abstract long start();
+    public abstract long len();
+    public abstract int pid();
+}
diff --git a/src/main/java/jnr/posix/FreeBSDCmsgHdr.java b/src/main/java/jnr/posix/FreeBSDCmsgHdr.java
new file mode 100644
index 0000000..b9ae98c
--- /dev/null
+++ b/src/main/java/jnr/posix/FreeBSDCmsgHdr.java
@@ -0,0 +1,72 @@
+package jnr.posix;
+
+import jnr.ffi.Pointer;
+import jnr.ffi.Runtime;
+import jnr.ffi.StructLayout;
+
+/**
+ * @author Bob McWhirter
+ */
+class FreeBSDCmsgHdr extends BaseCmsgHdr {
+
+    public static class Layout extends StructLayout {
+
+        protected Layout(Runtime runtime) {
+            super(runtime);
+        }
+
+        public final socklen_t cmsg_len = new socklen_t();
+        public final Signed32 cmsg_level = new Signed32();
+        public final Signed32 cmsg_type = new Signed32();
+    }
+
+    public static final Layout layout = new Layout(Runtime.getSystemRuntime());
+
+    public FreeBSDCmsgHdr(NativePOSIX posix, Pointer memory) {
+        super(posix, memory);
+    }
+
+    public FreeBSDCmsgHdr(NativePOSIX posix, Pointer memory, int totalLen) {
+        super(posix, memory, totalLen);
+    }
+
+    public void setLevel(int level) {
+        layout.cmsg_level.set(this.memory, level);
+    }
+
+    public int getLevel() {
+        return layout.cmsg_level.get(this.memory);
+    }
+
+    public void setType(int type) {
+        layout.cmsg_type.set(this.memory, type);
+    }
+
+    public int getType() {
+        return layout.cmsg_type.get(this.memory);
+    }
+
+    public int getLen() {
+        return (int) layout.cmsg_len.get(this.memory);
+    }
+
+    void setLen(int len) {
+        layout.cmsg_len.set(this.memory, len);
+    }
+
+    public String toString(String indent) {
+        StringBuffer buf = new StringBuffer();
+
+        buf.append(indent).append("cmsg {\n");
+        buf.append(indent).append("  cmsg_len=").append(layout.cmsg_len.get(this.memory)).append("\n");
+        buf.append(indent).append("  cmsg_level=").append(layout.cmsg_level.get(this.memory)).append("\n");
+        buf.append(indent).append("  cmsg_type=").append(layout.cmsg_type.get(this.memory)).append("\n");
+        buf.append(indent).append("  cmsg_data=").append(getData()).append("\n");
+        buf.append(indent).append("}");
+        return buf.toString();
+    }
+
+    public String toString(){
+        return toString( "" );
+    }
+}
diff --git a/src/main/java/jnr/posix/FreeBSDFileStat.java b/src/main/java/jnr/posix/FreeBSDFileStat.java
new file mode 100644
index 0000000..ec01140
--- /dev/null
+++ b/src/main/java/jnr/posix/FreeBSDFileStat.java
@@ -0,0 +1,142 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+
+public final class FreeBSDFileStat extends BaseFileStat implements NanosecondFileStat {
+    private static final class Layout extends StructLayout {
+
+        private Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final class time_t extends SignedLong {}
+        public final class dev_t extends Signed32 {}
+
+        public final dev_t  st_dev = new dev_t();
+        public final Signed32  st_ino = new Signed32();
+        public final Signed16  st_mode = new Signed16();
+        public final Signed16  st_nlink = new Signed16();
+        public final Signed32  st_uid = new Signed32();
+        public final Signed32  st_gid = new Signed32();
+        public final dev_t  st_rdev = new dev_t();
+        public final time_t st_atime = new time_t();
+        public final SignedLong st_atimensec = new SignedLong();
+        public final time_t st_mtime = new time_t();
+        public final SignedLong st_mtimensec = new SignedLong();
+        public final time_t st_ctime = new time_t();
+        public final SignedLong st_ctimensec = new SignedLong();
+        public final Signed64  st_size = new Signed64();
+        public final Signed64  st_blocks = new Signed64();
+        public final Signed32  st_blksize = new Signed32();
+        public final Signed32  st_flags = new Signed32();
+        public final Signed32  st_gen = new Signed32();
+        public final Signed32  st_lspare = new Signed32();
+        public final time_t    st_birthtime = new time_t();
+        public final SignedLong st_birthtimensec = new SignedLong();
+        /* FIXME: This padding isn't quite correct */
+        public final Signed64  st_qspare0 = new Signed64();
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public FreeBSDFileStat(NativePOSIX posix) {
+        super(posix, layout);
+    }
+
+    public long atime() {
+        return layout.st_atime.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctime.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return layout.st_mode.get(memory) & 0xffff;
+    }
+
+    public long mtime() {
+        return layout.st_mtime.get(memory);
+    }
+
+    public int nlink() {
+        return layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout.st_size.get(memory);
+    }
+
+    public int uid() {
+        return layout.st_uid.get(memory);
+    }
+
+    @Override
+    public long aTimeNanoSecs() {
+        return layout.st_atimensec.get(memory);
+    }
+
+    @Override
+    public long cTimeNanoSecs() {
+        return layout.st_ctimensec.get(memory);
+    }
+
+    @Override
+    public long mTimeNanoSecs() {
+        return layout.st_mtimensec.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/FreeBSDFileStat12.java b/src/main/java/jnr/posix/FreeBSDFileStat12.java
new file mode 100644
index 0000000..8e4633f
--- /dev/null
+++ b/src/main/java/jnr/posix/FreeBSDFileStat12.java
@@ -0,0 +1,145 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+
+public final class FreeBSDFileStat12 extends BaseFileStat implements NanosecondFileStat {
+    private static final class Layout extends StructLayout {
+
+        private Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final class time_t extends SignedLong {}
+        public final class dev_t extends Signed32 {}
+
+        public final dev_t  st_dev = new dev_t();
+        public final Signed64  st_ino = new Signed64();
+        // FIXME: this should be a 64-bit field
+        public final Signed32  st_nlink_upper = new Signed32();
+        public final Signed32  st_nlink = new Signed32();
+        public final Signed16  st_mode = new Signed16();
+        public final Signed16  st_padding0 = new Signed16();
+        public final Signed32  st_uid = new Signed32();
+        public final Signed32  st_gid = new Signed32();
+        public final Signed32  st_padding1 = new Signed32();
+        public final dev_t  st_rdev = new dev_t();
+        public final time_t st_atime = new time_t();
+        public final SignedLong st_atimensec = new SignedLong();
+        public final time_t st_mtime = new time_t();
+        public final SignedLong st_mtimensec = new SignedLong();
+        public final time_t st_ctime = new time_t();
+        public final SignedLong st_ctimensec = new SignedLong();
+        public final time_t    st_birthtime = new time_t();
+        public final SignedLong st_birthtimensec = new SignedLong();
+        public final Signed64  st_size = new Signed64();
+        public final Signed64  st_blocks = new Signed64();
+        public final Signed32  st_blksize = new Signed32();
+        public final Signed32  st_flags = new Signed32();
+        public final Signed64  st_gen = new Signed64();
+        /* FIXME: This padding isn't quite correct */
+        public final Signed64  st_qspare0 = new Signed64();
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public FreeBSDFileStat12(NativePOSIX posix) {
+        super(posix, layout);
+    }
+
+    public long atime() {
+        return layout.st_atime.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctime.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return layout.st_mode.get(memory) & 0xffff;
+    }
+
+    public long mtime() {
+        return layout.st_mtime.get(memory);
+    }
+
+    public int nlink() {
+        return layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout.st_size.get(memory);
+    }
+
+    public int uid() {
+        return layout.st_uid.get(memory);
+    }
+
+    @Override
+    public long aTimeNanoSecs() {
+        return layout.st_atimensec.get(memory);
+    }
+
+    @Override
+    public long cTimeNanoSecs() {
+        return layout.st_ctimensec.get(memory);
+    }
+
+    @Override
+    public long mTimeNanoSecs() {
+        return layout.st_mtimensec.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/FreeBSDMsgHdr.java b/src/main/java/jnr/posix/FreeBSDMsgHdr.java
new file mode 100644
index 0000000..92e7f20
--- /dev/null
+++ b/src/main/java/jnr/posix/FreeBSDMsgHdr.java
@@ -0,0 +1,151 @@
+package jnr.posix;
+
+import java.util.ArrayList;
+import java.util.List;
+import jnr.ffi.Pointer;
+import jnr.ffi.Runtime;
+import jnr.ffi.StructLayout;
+
+/**
+ * @author Bob McWhirter
+ */
+class FreeBSDMsgHdr extends BaseMsgHdr {
+
+    public static class Layout extends StructLayout {
+        protected Layout(Runtime runtime) {
+            super(runtime);
+        }
+
+        public final Pointer msg_name = new Pointer();
+        public final socklen_t msg_namelen = new socklen_t();
+        public final Pointer msg_iov = new Pointer();
+        public final Signed32 msg_iovlen = new Signed32();
+        public final Pointer msg_control = new Pointer();
+        public final socklen_t msg_controllen = new socklen_t();
+        public final Signed32 msg_flags = new Signed32();
+    }
+
+    private static final Layout layout = new Layout(Runtime.getSystemRuntime());
+
+    protected FreeBSDMsgHdr(NativePOSIX posix) {
+        super(posix, layout);
+        setName(null);
+    }
+
+    CmsgHdr allocateCmsgHdrInternal(NativePOSIX posix, Pointer pointer, int len) {
+        if (len > 0) {
+            return new FreeBSDCmsgHdr(posix, pointer, len);
+        } else {
+            return new FreeBSDCmsgHdr(posix, pointer);
+        }
+    }
+
+    @Override
+    void setControlPointer(Pointer control) {
+        layout.msg_control.set(this.memory, control);
+    }
+
+    @Override
+    void setControlLen(int len) {
+        layout.msg_controllen.set(this.memory, len);
+    }
+
+    public String toString() {
+        StringBuffer buf = new StringBuffer();
+        buf.append("msghdr {\n");
+        buf.append("  msg_name=").append(getName()).append(",\n");
+        buf.append("  msg_namelen=").append(getNameLen()).append(",\n");
+
+        buf.append("  msg_iov=[\n");
+        Pointer iovp = layout.msg_iov.get(this.memory);
+
+        int numIov = getIovLen();
+        for (int i = 0; i < numIov; ++i) {
+            Pointer eachp = iovp.slice(i * BaseIovec.layout.size());
+            buf.append(new BaseIovec(posix, eachp).toString("    "));
+            if (i < (numIov - 1)) {
+                buf.append(",\n");
+            } else {
+                buf.append("\n");
+            }
+        }
+        buf.append("  ],\n");
+
+        buf.append("  msg_control=[\n");
+
+        CmsgHdr[] controls = getControls();
+        for (int i = 0; i < controls.length; ++i) {
+            buf.append(((FreeBSDCmsgHdr) controls[i]).toString("    "));
+            if (i < controls.length - 1) {
+                buf.append(",\n");
+            } else {
+                buf.append("\n");
+            }
+        }
+        buf.append("  ],\n");
+        buf.append("  msg_controllen=").append(layout.msg_controllen.get(this.memory)).append("\n");
+
+        buf.append("  msg_iovlen=").append(getIovLen()).append(",\n");
+        buf.append("  msg_flags=").append(getFlags()).append(",\n");
+        buf.append("}");
+        return buf.toString();
+    }
+
+    @Override
+    void setNamePointer(Pointer name) {
+        layout.msg_name.set( this.memory, name );
+    }
+
+    @Override
+    Pointer getNamePointer() {
+        return layout.msg_name.get( this.memory );
+    }
+
+
+    @Override
+    void setNameLen(int len) {
+        layout.msg_namelen.set(this.memory, len);
+    }
+
+    @Override
+    int getNameLen() {
+        return (int) layout.msg_namelen.get(this.memory);
+    }
+
+    @Override
+    void setIovPointer(Pointer iov) {
+        layout.msg_iov.set(this.memory, iov);
+    }
+
+    @Override
+    Pointer getIovPointer() {
+        return layout.msg_iov.get( this.memory );
+    }
+
+    @Override
+    void setIovLen(int len) {
+        layout.msg_iovlen.set(this.memory, len);
+    }
+
+    @Override
+    int getIovLen() {
+        return (int) layout.msg_iovlen.get(this.memory);
+    }
+
+    @Override
+    Pointer getControlPointer() {
+        return layout.msg_control.get(this.memory);
+    }
+
+    public int getControlLen() {
+        return (int) layout.msg_controllen.get(this.memory);
+    }
+
+    public void setFlags(int flags) {
+        layout.msg_flags.set(this.memory, flags);
+    }
+
+    public int getFlags() {
+        return layout.msg_flags.get(this.memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/FreeBSDPOSIX.java b/src/main/java/jnr/posix/FreeBSDPOSIX.java
new file mode 100644
index 0000000..ebb05d8
--- /dev/null
+++ b/src/main/java/jnr/posix/FreeBSDPOSIX.java
@@ -0,0 +1,121 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+import jnr.constants.platform.Sysconf;
+import jnr.ffi.Memory;
+import jnr.ffi.mapper.FromNativeContext;
+import jnr.ffi.Pointer;
+import jnr.posix.util.MethodName;
+
+import java.lang.Runtime;
+import java.io.InputStreamReader;
+import java.io.BufferedReader;
+import java.nio.ByteBuffer;
+import java.text.NumberFormat;
+import java.text.ParsePosition;
+import jnr.constants.platform.Confstr;
+import jnr.constants.platform.Pathconf;
+
+final class FreeBSDPOSIX extends BaseNativePOSIX {
+    private final int freebsdVersion;
+
+    FreeBSDPOSIX(LibCProvider libc, POSIXHandler handler) {
+        super(libc, handler);
+
+        int parsed_version = 0;
+
+        // FreeBSD 12 introduces a new stat structure. Until jffi gets dlvsym() support
+        // to allow us to link explicitly to supported versions of functions, detect
+        // the current userspace version and cross our fingers.
+        try {
+            Process p = Runtime.getRuntime().exec("/bin/freebsd-version -u");
+            String version = new BufferedReader(new InputStreamReader(p.getInputStream())).readLine();
+
+            if (p.waitFor() == 0 && version != null) {
+                NumberFormat fmt = NumberFormat.getIntegerInstance();
+                fmt.setGroupingUsed(false);
+
+                parsed_version = fmt.parse(version, new ParsePosition(0)).intValue();
+            }
+        } catch (Exception e) { }
+
+        freebsdVersion = parsed_version;
+    }
+
+    public FileStat allocateStat() {
+        if (freebsdVersion >= 12) {
+            return new FreeBSDFileStat12(this);
+        } else {
+            return new FreeBSDFileStat(this);
+        }
+    }
+
+    public MsgHdr allocateMsgHdr() {
+        return new FreeBSDMsgHdr(this);
+    }
+
+    public SocketMacros socketMacros() {
+        return FreeBSDSocketMacros.INSTANCE;
+    }
+
+    public long sysconf(Sysconf name) {
+        return libc().sysconf(name);
+    }
+
+    public int confstr(Confstr name, ByteBuffer buf, int len) {
+        return libc().confstr(name, buf, len);
+    }
+
+    public int fpathconf(int fd, Pathconf name) {
+        return libc().fpathconf(fd, name);
+    }
+
+    public Times times() {
+        return NativeTimes.times(this);
+    }
+
+
+    public static final PointerConverter PASSWD = new PointerConverter() {
+        public Object fromNative(Object arg, FromNativeContext ctx) {
+            return arg != null ? new FreeBSDPasswd((Pointer) arg) : null;
+        }
+    };
+
+    public Pointer allocatePosixSpawnFileActions() {
+        return Memory.allocateDirect(getRuntime(), 8);
+    }
+
+    public Pointer allocatePosixSpawnattr() {
+        return Memory.allocateDirect(getRuntime(), 8);
+    }
+}
diff --git a/src/main/java/jnr/posix/FreeBSDPasswd.java b/src/main/java/jnr/posix/FreeBSDPasswd.java
new file mode 100644
index 0000000..3345162
--- /dev/null
+++ b/src/main/java/jnr/posix/FreeBSDPasswd.java
@@ -0,0 +1,101 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+
+import jnr.ffi.StructLayout;
+
+public class FreeBSDPasswd extends NativePasswd implements Passwd {
+    private static final class Layout extends StructLayout {
+
+        private Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final UTF8StringRef pw_name = new UTF8StringRef();   // user name
+        public final UTF8StringRef pw_passwd = new UTF8StringRef(); // password (encrypted)
+        public final Signed32 pw_uid = new Signed32();       // user id
+        public final Signed32 pw_gid = new Signed32();       // user id
+        public final SignedLong pw_change = new SignedLong();// password change time
+        public final UTF8StringRef pw_class = new UTF8StringRef();  // user access class
+        public final UTF8StringRef pw_gecos = new UTF8StringRef();  // login info
+        public final UTF8StringRef pw_dir = new UTF8StringRef();    // home directory
+        public final UTF8StringRef pw_shell = new UTF8StringRef();  // default shell
+        public final SignedLong pw_expire = new SignedLong();    // account expiration
+        public final Signed32 pw_fields = new Signed32();    // internal: fields filled in
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    FreeBSDPasswd(jnr.ffi.Pointer memory) {
+        super(memory);
+    }
+
+    public java.lang.String getAccessClass() {
+        return layout.pw_class.get(memory);
+    }
+
+    public java.lang.String getGECOS() {
+        return layout.pw_gecos.get(memory);
+    }
+
+    public long getGID() {
+        return layout.pw_gid.get(memory);
+    }
+
+    public java.lang.String getHome() {
+        return layout.pw_dir.get(memory);
+    }
+
+    public java.lang.String getLoginName() {
+        return layout.pw_name.get(memory);
+    }
+
+    public int getPasswdChangeTime() {
+        return layout.pw_change.intValue(memory);
+    }
+
+    public java.lang.String getPassword() {
+        return layout.pw_passwd.get(memory);
+    }
+
+    public java.lang.String getShell() {
+        return layout.pw_shell.get(memory);
+    }
+
+    public long getUID() {
+        return layout.pw_uid.get(memory);
+    }
+
+    public int getExpire() {
+        return layout.pw_expire.intValue(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/FreeBSDSocketMacros.java b/src/main/java/jnr/posix/FreeBSDSocketMacros.java
new file mode 100644
index 0000000..c254d38
--- /dev/null
+++ b/src/main/java/jnr/posix/FreeBSDSocketMacros.java
@@ -0,0 +1,29 @@
+package jnr.posix;
+
+import jnr.ffi.*;
+import jnr.ffi.Runtime;
+
+/**
+ * @author Bob McWhirter
+ */
+public class FreeBSDSocketMacros implements SocketMacros {
+
+    public static final FreeBSDSocketMacros INSTANCE = new FreeBSDSocketMacros();
+
+    public int CMSG_ALIGN(int len) {
+        int sizeof_size_t = Runtime.getSystemRuntime().findType(TypeAlias.size_t).size();
+        return (len + sizeof_size_t - 1) & ~(sizeof_size_t - 1);
+    }
+
+    public int CMSG_SPACE(int l) {
+        return CMSG_ALIGN(FreeBSDCmsgHdr.layout.size()) + CMSG_ALIGN(l);
+    }
+
+    public int CMSG_LEN(int l) {
+        return CMSG_ALIGN( FreeBSDCmsgHdr.layout.size() ) + (l);
+    }
+
+    public Pointer CMSG_DATA(Pointer cmsg) {
+        return cmsg.slice(CMSG_ALIGN(FreeBSDCmsgHdr.layout.size()));
+    }
+}
diff --git a/src/main/java/jnr/posix/Group.java b/src/main/java/jnr/posix/Group.java
new file mode 100644
index 0000000..dd9621b
--- /dev/null
+++ b/src/main/java/jnr/posix/Group.java
@@ -0,0 +1,8 @@
+package jnr.posix;
+
+public interface Group {
+    public String getName();
+    public String getPassword();
+    public long getGID();
+    public String[] getMembers();
+}
diff --git a/src/main/java/jnr/posix/HANDLE.java b/src/main/java/jnr/posix/HANDLE.java
new file mode 100644
index 0000000..825f808
--- /dev/null
+++ b/src/main/java/jnr/posix/HANDLE.java
@@ -0,0 +1,46 @@
+package jnr.posix;
+
+import jnr.ffi.Pointer;
+import jnr.ffi.mapper.DataConverter;
+import jnr.ffi.mapper.FromNativeContext;
+import jnr.ffi.mapper.ToNativeContext;
+
+public final class HANDLE {
+    public static final long INVALID_HANDLE_VALUE = -1L;
+    private final Pointer pointer;
+
+    public HANDLE(Pointer pointer) {
+        this.pointer = pointer;
+    }
+
+    public final Pointer toPointer() {
+        return pointer;
+    }
+
+    public final boolean isValid() {
+        return pointer.address() != (INVALID_HANDLE_VALUE & jnr.ffi.Runtime.getSystemRuntime().addressMask());
+    }
+
+    public static HANDLE valueOf(Pointer value) {
+        return new HANDLE(value);
+    }
+
+    public static HANDLE valueOf(long value) {
+        return new HANDLE(jnr.ffi.Runtime.getSystemRuntime().getMemoryManager().newPointer(value));
+    }
+
+    public static final DataConverter<HANDLE, Pointer> Converter = new DataConverter<HANDLE, Pointer>() {
+
+        public Pointer toNative(HANDLE value, ToNativeContext context) {
+            return value != null ? value.pointer : null;
+        }
+
+        public HANDLE fromNative(Pointer nativeValue, FromNativeContext context) {
+            return nativeValue != null ? new HANDLE(nativeValue) : null;
+        }
+
+        public Class<Pointer> nativeType() {
+            return Pointer.class;
+        }
+    };
+}
diff --git a/src/main/java/jnr/posix/Iovec.java b/src/main/java/jnr/posix/Iovec.java
new file mode 100644
index 0000000..310d878
--- /dev/null
+++ b/src/main/java/jnr/posix/Iovec.java
@@ -0,0 +1,12 @@
+package jnr.posix;
+
+import java.nio.ByteBuffer;
+
+/**
+ * @author Bob McWhirter
+ */
+public interface Iovec {
+
+    ByteBuffer get();
+    void set(ByteBuffer buf);
+}
diff --git a/src/main/java/jnr/posix/JavaFileStat.java b/src/main/java/jnr/posix/JavaFileStat.java
new file mode 100644
index 0000000..e6991ec
--- /dev/null
+++ b/src/main/java/jnr/posix/JavaFileStat.java
@@ -0,0 +1,317 @@
+package jnr.posix;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.nio.file.attribute.DosFileAttributes;
+import java.nio.file.attribute.FileTime;
+import java.nio.file.attribute.PosixFileAttributes;
+import java.nio.file.attribute.PosixFilePermission;
+import java.util.Set;
+
+public class JavaFileStat extends AbstractJavaFileStat {
+    short st_mode;
+
+    BasicFileAttributes attrs;
+    PosixFileAttributes posixAttrs;
+    DosFileAttributes dosAttrs;
+    
+    public JavaFileStat(POSIX posix, POSIXHandler handler) {
+        super(posix, handler);
+    }
+    
+    public void setup(String filePath) {
+        File file = new JavaSecuredFile(filePath);
+        Path path = file.toPath();
+
+        try {
+            try {
+                // try POSIX
+                posixAttrs = Files.readAttributes(path, PosixFileAttributes.class, LinkOption.NOFOLLOW_LINKS);
+                attrs = posixAttrs;
+            } catch (UnsupportedOperationException uoe) {
+                try {
+                    // try DOS
+                    dosAttrs = Files.readAttributes(path, DosFileAttributes.class, LinkOption.NOFOLLOW_LINKS);
+                    attrs = dosAttrs;
+                } catch (UnsupportedOperationException uoe2) {
+                    attrs = Files.readAttributes(path, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS);
+                }
+            }
+        } catch (IOException ioe) {
+            // fall back on pre-NIO2 logic
+            attrs = new PreNIO2FileAttributes(file);
+        }
+
+        // Simulated mode value
+        st_mode = calculateMode(file, (short) 0);
+    }
+
+    private class PreNIO2FileAttributes implements BasicFileAttributes {
+        final long st_size;
+        final int st_ctime;
+        final int st_mtime;
+        final boolean regularFile;
+        final boolean directory;
+
+        PreNIO2FileAttributes(File file) {
+            st_size = file.length();
+
+            st_mtime = (int) (file.lastModified() / 1000);
+
+            // Parent file last modified will only represent when something was added or removed.
+            // This is not correct, but it is better than nothing and does work in one common use
+            // case.
+            if (file.getParentFile() != null) {
+                st_ctime = (int) (file.getParentFile().lastModified() / 1000);
+            } else {
+                st_ctime = st_mtime;
+            }
+
+            regularFile = file.isFile();
+            directory = file.isDirectory();
+        }
+
+        @Override
+        public FileTime lastModifiedTime() {
+            return FileTime.fromMillis(st_mtime);
+        }
+
+        @Override
+        public FileTime lastAccessTime() {
+            return lastModifiedTime();
+        }
+
+        @Override
+        public FileTime creationTime() {
+            return FileTime.fromMillis(st_mtime);
+        }
+
+        @Override
+        public boolean isRegularFile() {
+            return (st_mode & S_IFREG) != 0;
+        }
+
+        @Override
+        public boolean isDirectory() {
+            return (st_mode & S_IFDIR) != 0;
+        }
+
+        @Override
+        public boolean isSymbolicLink() {
+            return (st_mode & S_IFLNK) != 0;
+        }
+
+        @Override
+        public boolean isOther() {
+            return !(isRegularFile() || isDirectory() || isSymbolicLink());
+        }
+
+        @Override
+        public long size() {
+            return st_size;
+        }
+
+        @Override
+        public Object fileKey() {
+            return null;
+        }
+    }
+
+    private short calculateMode(File file, short st_mode) {
+        // implementation to lowest common denominator...
+        // Windows has no file mode, but C ruby returns either 0100444 or 0100644
+
+        if (file.canRead()) {
+            st_mode |= ALL_READ;
+        }
+
+        if (file.canWrite()) {
+            st_mode |= ALL_WRITE;
+            st_mode &= ~(S_IWGRP | S_IWOTH);
+        }
+
+        if (file.isDirectory()) {
+            st_mode |= S_IFDIR;
+        } else if (file.isFile()) {
+            st_mode |= S_IFREG;
+        }
+
+        if (posixAttrs != null && posixAttrs.isSymbolicLink()) {
+            st_mode |= S_IFLNK;
+        } else {
+            try {
+                st_mode = calculateSymlink(file, st_mode);
+            } catch (IOException e) {
+                // Not sure we can do much in this case...
+            }
+        }
+
+        return st_mode;
+    }
+
+    private static short calculateSymlink(File file, short st_mode) throws IOException {
+        if (file.getAbsoluteFile().getParentFile() == null) {
+            return st_mode;
+        }
+
+        File absoluteParent = file.getAbsoluteFile().getParentFile();
+        File canonicalParent = absoluteParent.getCanonicalFile();
+
+        if (canonicalParent.getAbsolutePath().equals(absoluteParent.getAbsolutePath())) {
+            // parent doesn't change when canonicalized, compare absolute and canonical file directly
+            if (!file.getAbsolutePath().equalsIgnoreCase(file.getCanonicalPath())) {
+                st_mode |= S_IFLNK;
+                return st_mode;
+            }
+        }
+
+        // directory itself has symlinks (canonical != absolute), so build new path with canonical parent and compare
+        file = new JavaSecuredFile(canonicalParent.getAbsolutePath() + "/" + file.getName());
+        if (!file.getAbsolutePath().equalsIgnoreCase(file.getCanonicalPath())) {
+            st_mode |= S_IFLNK;
+        }
+
+        return st_mode;
+    }
+
+    /**
+     * Limitation: Java has no access time support, so we return mtime as the next best thing.
+     */
+    public long atime() {
+        return (int) (attrs.lastAccessTime().toMillis() / 1000);
+    }
+
+    public long ctime() {
+        return (int) (attrs.creationTime().toMillis() / 1000);
+    }
+
+    public boolean isDirectory() {
+        return attrs.isDirectory();
+    }
+
+    public boolean isEmpty() {
+        return attrs.size() == 0;
+    }
+
+    public boolean isExecutable() {
+        if (posixAttrs != null) {
+            Set<PosixFilePermission> permissions = posixAttrs.permissions();
+
+            return permissions.contains(PosixFilePermission.OWNER_EXECUTE) ||
+                    permissions.contains(PosixFilePermission.GROUP_EXECUTE) ||
+                    permissions.contains(PosixFilePermission.OTHERS_EXECUTE);
+        }
+
+        // silently return false, since it's likely an unusual filesystem
+        return false;
+    }
+
+    public boolean isExecutableReal() {
+        return isExecutable();
+    }
+
+    public boolean isFile() {
+        return attrs.isRegularFile();
+    }
+    
+    public boolean isGroupOwned() {
+        return groupMember(gid());
+    }
+
+    public boolean isIdentical(FileStat other) {
+        // if attrs supports file keys, we can compare them
+        Object key = attrs.fileKey();
+
+        if (key != null && other instanceof JavaFileStat) {
+            JavaFileStat otherStat = (JavaFileStat) other;
+
+            return key.equals(otherStat.attrs.fileKey());
+        }
+
+        handler.unimplementedError("identical file detection");
+        
+        return false;
+    }
+
+    public boolean isOwned() {
+        return posix.geteuid() == uid();
+    }
+
+    public boolean isROwned() {
+        return posix.getuid() == uid();
+    }
+
+    public boolean isReadable() {
+        if (posixAttrs != null) {
+            Set<PosixFilePermission> permissions = posixAttrs.permissions();
+
+            return permissions.contains(PosixFilePermission.OWNER_READ) ||
+                    permissions.contains(PosixFilePermission.GROUP_READ) ||
+                    permissions.contains(PosixFilePermission.OTHERS_READ);
+        }
+
+        int mode = mode();
+        
+        if ((mode & S_IRUSR) != 0) return true;
+        if ((mode & S_IRGRP) != 0) return true;
+        if ((mode & S_IROTH) != 0) return true;
+        
+        return false;
+    }
+
+    // We do both readable and readable_real through the same method because
+    public boolean isReadableReal() {
+        return isReadable();
+    }
+
+    public boolean isSymlink() {
+        if (posixAttrs != null) {
+            return posixAttrs.isSymbolicLink();
+        }
+
+        return (mode() & S_IFLNK) == S_IFLNK;
+    }
+    
+    public boolean isWritable() {
+        if (posixAttrs != null) {
+            Set<PosixFilePermission> permissions = posixAttrs.permissions();
+
+            return permissions.contains(PosixFilePermission.OWNER_WRITE) ||
+                    permissions.contains(PosixFilePermission.GROUP_WRITE) ||
+                    permissions.contains(PosixFilePermission.OTHERS_WRITE);
+        } else if (dosAttrs != null) {
+            return !dosAttrs.isReadOnly();
+        }
+
+        int mode = mode();
+        
+        if ((mode & S_IWUSR) != 0) return true;
+        if ((mode & S_IWGRP) != 0) return true;
+        if ((mode & S_IWOTH) != 0) return true;
+
+        return false;
+    }
+    
+    // We do both readable and readable_real through the same method because
+    // in our java process effective and real userid will always be the same.
+    public boolean isWritableReal() {
+        return isWritable();
+    }
+
+    public int mode() {
+        return st_mode & 0xffff;
+    }
+
+    public long mtime() {
+        return (int) (attrs.lastModifiedTime().toMillis() / 1000);
+    }
+
+    public long st_size() {
+        return attrs.size();
+    }
+
+}
diff --git a/src/main/java/jnr/posix/JavaLibCHelper.java b/src/main/java/jnr/posix/JavaLibCHelper.java
new file mode 100644
index 0000000..e8547ff
--- /dev/null
+++ b/src/main/java/jnr/posix/JavaLibCHelper.java
@@ -0,0 +1,528 @@
+ /*
+ **** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Copyright (C) 2007 
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+package jnr.posix;
+
+import static jnr.constants.platform.Errno.*;
+
+import java.io.*;
+import java.lang.management.ManagementFactory;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.nio.ByteBuffer;
+import java.nio.channels.Channel;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.regex.Pattern;
+
+import jnr.constants.platform.Errno;
+import jnr.posix.util.Chmod;
+import jnr.posix.util.ExecIt;
+import jnr.posix.util.JavaCrypt;
+import jnr.posix.util.Platform;
+
+ /**
+ * This libc implementation is created one per runtime instance versus the others which
+ * are expected to be one static instance for whole JVM.  Because of this it is no big
+ * deal to make reference to a POSIXHandler directly.
+ */
+// FIXME: we ignore all exceptions with shell launcher...should we do something better
+public class JavaLibCHelper {
+    public static final int STDIN = 0;
+    public static final int STDOUT = 1;
+    public static final int STDERR = 2;
+
+    private static final ThreadLocal<Integer> errno = new ThreadLocal<Integer>();
+
+    private final POSIXHandler handler;
+    private final Map<String, String> env;
+    
+
+    public JavaLibCHelper(POSIXHandler handler) {
+        this.env = new HashMap<String, String>();
+        this.handler = handler;
+    }
+    
+    private static class ReflectiveAccess {
+        private static final Class SEL_CH_IMPL;
+        private static final Method SEL_CH_IMPL_GET_FD;
+        private static final Class FILE_CHANNEL_IMPL;
+        private static final Field FILE_CHANNEL_IMPL_FD;
+        private static final Field FILE_DESCRIPTOR_FD;
+        private static final Field FILE_DESCRIPTOR_HANDLE;
+
+        static {
+            try {
+                Method getModule = Class.class.getMethod("getModule");
+                Class<?> Module = Class.forName("java.lang.Module");
+                Method isOpen = Module.getMethod("isOpen", String.class, Module);
+                Method isNamed = Module.getMethod("isNamed");
+                Method addOpens = Module.getMethod("addOpens", String.class, Module);
+                Object JNRPosixModule = getModule.invoke(ReflectiveAccess.class);
+                Object JavaBaseModule = getModule.invoke(FileDescriptor.class);
+
+                if (!((Boolean) isOpen.invoke(JavaBaseModule, "java.io", JNRPosixModule))) {
+                    // warn that many APIs will be broken without module access
+                    System.err.println("Some JDK modules may not be open to jnr-posix, which will break file descriptor and process APIs. See https://github.com/jnr/jnr-posix/wiki/Using-POSIX-with-Java-Modules");
+                } else if (!((Boolean) isNamed.invoke(JNRPosixModule))) {
+                    // explicitly open them to avoid the implicitly open warning
+                    addOpens.invoke(JavaBaseModule, "java.io", JNRPosixModule);
+                    addOpens.invoke(JavaBaseModule, "sun.nio.ch", JNRPosixModule);
+                }
+            } catch (Exception e) {
+                // ignore, we're not on Java 9+
+            }
+
+            Method getFD;
+            Class selChImpl;
+            try {
+                selChImpl = Class.forName("sun.nio.ch.SelChImpl");
+                try {
+                    getFD = selChImpl.getMethod("getFD");
+                    getFD.setAccessible(true);
+                } catch (Exception e) {
+                    getFD = null;
+                }
+            } catch (Exception e) {
+                selChImpl = null;
+                getFD = null;
+            }
+            SEL_CH_IMPL = selChImpl;
+            SEL_CH_IMPL_GET_FD = getFD;
+
+            Field fd;
+            Class fileChannelImpl;
+            try {
+                fileChannelImpl = Class.forName("sun.nio.ch.FileChannelImpl");
+                try {
+                    fd = fileChannelImpl.getDeclaredField("fd");
+                    fd.setAccessible(true);
+                } catch (Exception e) {
+                    fd = null;
+                }
+            } catch (Exception e) {
+                fileChannelImpl = null;
+                fd = null;
+            }
+            FILE_CHANNEL_IMPL = fileChannelImpl;
+            FILE_CHANNEL_IMPL_FD = fd;
+
+            Field ffd;
+            try {
+                ffd = FileDescriptor.class.getDeclaredField("fd");
+                ffd.setAccessible(true);
+            } catch (Exception e) {
+                ffd = null;
+            }
+            FILE_DESCRIPTOR_FD = ffd;
+
+            if (Platform.IS_WINDOWS) {
+                Field handle;
+                try {
+                    handle = FileDescriptor.class.getDeclaredField("handle");
+                    handle.setAccessible(true);
+                } catch (Exception e) {
+                    handle = null;
+                }
+                FILE_DESCRIPTOR_HANDLE = handle;
+            } else {
+                FILE_DESCRIPTOR_HANDLE = null;
+            }
+        }
+    }
+
+    public static FileDescriptor getDescriptorFromChannel(Channel channel) {
+        if (ReflectiveAccess.SEL_CH_IMPL_GET_FD != null && ReflectiveAccess.SEL_CH_IMPL.isInstance(channel)) {
+            // Pipe Source and Sink, Sockets, and other several other selectable channels
+            try {
+                return (FileDescriptor)ReflectiveAccess.SEL_CH_IMPL_GET_FD.invoke(channel);
+            } catch (Exception e) {
+                // return bogus below
+            }
+        } else if (ReflectiveAccess.FILE_CHANNEL_IMPL_FD != null && ReflectiveAccess.FILE_CHANNEL_IMPL.isInstance(channel)) {
+            // FileChannels
+            try {
+                return (FileDescriptor)ReflectiveAccess.FILE_CHANNEL_IMPL_FD.get(channel);
+            } catch (Exception e) {
+                // return bogus below
+            }
+        } else if (ReflectiveAccess.FILE_DESCRIPTOR_FD != null) {
+            // anything else that implements a getFD method that returns an int
+            FileDescriptor unixFD = new FileDescriptor();
+            
+                try {
+                    Method getFD = channel.getClass().getMethod("getFD");
+                    ReflectiveAccess.FILE_DESCRIPTOR_FD.set(unixFD, (Integer)getFD.invoke(channel));
+                    return unixFD;
+                } catch (Exception e) {
+                    // return bogus below
+                }
+        }
+        return new FileDescriptor();
+    }
+
+    static int errno() {
+        Integer errno = JavaLibCHelper.errno.get();
+        return errno != null ? errno : 0;
+    }
+
+    static void errno(int errno) {
+        JavaLibCHelper.errno.set(errno);
+    }
+
+    static void errno(Errno errno) {
+        JavaLibCHelper.errno.set(errno.intValue());
+    }
+    
+    public int chmod(String filename, int mode) {
+        return Chmod.chmod(new JavaSecuredFile(filename), Integer.toOctalString(mode));
+    }
+
+    public int chown(String filename, int user, int group) {
+        PosixExec launcher = new PosixExec(handler);
+        int chownResult = -1;
+        int chgrpResult = -1;
+        
+        try {
+            if (user != -1) chownResult = launcher.runAndWait("chown", "" + user, filename);
+            if (group != -1) chgrpResult = launcher.runAndWait("chgrp ", "" + user, filename);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        } catch (Exception e) {
+        }
+        
+        return chownResult != -1 && chgrpResult != -1 ? 0 : 1;
+    }
+
+    public static CharSequence crypt(CharSequence original, CharSequence salt) {
+        return JavaCrypt.crypt(original, salt);
+    }
+
+    // FIXME: This version has no idea what charset you want, so it just uses default.
+    public static byte[] crypt(byte[] original, byte[] salt) {
+        return JavaCrypt.crypt(new String(original), new String(salt)).toString().getBytes();
+    }
+
+    public int getfd(FileDescriptor descriptor) {
+        return getfdFromDescriptor(descriptor);
+    }
+
+    public static int getfdFromDescriptor(FileDescriptor descriptor) {
+        if (descriptor == null || ReflectiveAccess.FILE_DESCRIPTOR_FD == null) return -1;
+        try {
+            return ReflectiveAccess.FILE_DESCRIPTOR_FD.getInt(descriptor);
+        } catch (SecurityException e) {
+        } catch (IllegalArgumentException e) {
+        } catch (IllegalAccessException e) {
+        }
+
+        return -1;
+    }
+
+     public static HANDLE gethandle(FileDescriptor descriptor) {
+         if (descriptor == null || ReflectiveAccess.FILE_DESCRIPTOR_HANDLE == null) return HANDLE.valueOf(-1);
+         try {
+             return gethandle(ReflectiveAccess.FILE_DESCRIPTOR_HANDLE.getLong(descriptor));
+         } catch (SecurityException e) {
+         } catch (IllegalArgumentException e) {
+         } catch (IllegalAccessException e) {
+         }
+
+         return HANDLE.valueOf(-1);
+     }
+
+     public static HANDLE gethandle(long descriptor) {
+         return HANDLE.valueOf(descriptor);
+     }
+
+    public String getlogin() {
+        return System.getProperty("user.name");
+    }
+
+    public String gethostname() {
+        String hn = System.getenv("HOSTNAME");
+        if (hn == null) hn = System.getenv("COMPUTERNAME");
+        return hn;
+    }
+
+    public int getpid() {
+        try {
+            return handler.getPID();
+        } catch (UnsupportedOperationException uoe) {
+            // if handler raises UOE, as our default handler does, try other ways
+
+            // Java 9+ provide ProcessHandle.current
+            try {
+                Class processHandle = Class.forName("java.lang.ProcessHandle");
+                Object current = processHandle.getMethod("current").invoke(null); // static
+                return (int) (long) (Long) processHandle.getMethod("pid").invoke(current);
+            } catch (Exception e) {
+                // ignore, try Java 8 logic below
+            }
+
+            // Java 8- can use management beans to infer the pid
+            try {
+                String runtimeName = ManagementFactory.getRuntimeMXBean().getName();
+                int index = runtimeName.indexOf('@');
+
+                if (index > 0) {
+                    return (int) Long.parseLong(runtimeName.substring(0, index));
+                }
+            } catch (Exception e) {
+                // ignore, rethrow UOE below
+            }
+
+            // couldn't do it, rethrow
+            throw uoe;
+        }
+
+    }
+    ThreadLocal<Integer> pwIndex = new ThreadLocal<Integer>() {
+        @Override
+        protected Integer initialValue() {
+            return 0;
+        }
+    };
+    public Passwd getpwent() {
+        Passwd retVal = pwIndex.get().intValue() == 0 ? new JavaPasswd(handler) : null;
+        pwIndex.set(pwIndex.get() + 1);
+        return retVal;
+    }
+
+    public int setpwent() {
+        return 0;
+    }
+
+    public int endpwent() {
+        pwIndex.set(0);
+        return 0;
+    }
+    public Passwd getpwuid(int which) {
+        return which == JavaPOSIX.LoginInfo.UID ? new JavaPasswd(handler) : null;
+    }
+    public int isatty(int fd) {
+        return (fd == STDOUT || fd == STDIN || fd == STDERR) ? 1 : 0;
+    }
+
+    public int link(String oldpath, String newpath) {
+        try {
+            return new PosixExec(handler).runAndWait("ln", oldpath, newpath);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        } catch (Exception e) {
+        }
+        errno(EINVAL);
+        return -1;  // We tried and failed for some reason. Indicate error.
+    }
+    
+    public int lstat(String path, FileStat stat) {
+        File file = new JavaSecuredFile(path);
+
+        if (!file.exists()) {
+            errno(ENOENT);
+            return -1;
+        }
+        
+        // FIXME: Bulletproof this or no?
+        JavaFileStat jstat = (JavaFileStat) stat;
+        
+        jstat.setup(path);
+
+        // TODO: Add error reporting for cases we can calculate: ENOTDIR, ENAMETOOLONG, ENOENT
+        // EACCES, ELOOP, EFAULT, EIO
+
+        return 0;
+    }
+    
+    public int mkdir(String path, int mode) {
+        File dir = new JavaSecuredFile(path);
+        
+        if (!dir.mkdir()) return -1;
+
+        chmod(path, mode);
+        
+        return 0;
+    }
+
+    public int rmdir(String path) {
+        return new JavaSecuredFile(path).delete() ? 0 : -1;
+    }
+
+    public static int chdir(String path) {
+        System.setProperty("user.dir", path);
+        return 0;
+    }
+    
+    public int stat(String path, FileStat stat) {
+        // FIXME: Bulletproof this or no?
+        JavaFileStat jstat = (JavaFileStat) stat;
+        
+        try {
+            File file = new JavaSecuredFile(path);
+            
+            if (!file.exists()) {
+                errno(ENOENT);
+                return -1;
+            }
+
+            jstat.setup(file.getCanonicalPath());
+        } catch (IOException e) {
+            // TODO: Throw error when we have problems stat'ing canonicalizing
+        }
+
+        // TODO: Add error reporting for cases we can calculate: ENOTDIR, ENAMETOOLONG,
+        // EACCES, ELOOP, EFAULT, EIO
+
+        return 0;
+    }
+
+    public int symlink(String oldpath, String newpath) {
+        try {
+            return new PosixExec(handler).runAndWait("ln", "-s", oldpath, newpath);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        } catch (Exception e) {
+        }
+        errno(EEXIST);
+        return -1;  // We tried and failed for some reason. Indicate error.
+
+    }
+
+    public int readlink(String oldpath, ByteBuffer buffer, int length) throws IOException {
+        try {
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            new PosixExec(handler).runAndWait(baos, "readlink", oldpath);
+            
+            byte[] bytes = baos.toByteArray();
+            
+            if (bytes.length > length || bytes.length == 0) return -1;
+            buffer.put(bytes, 0, bytes.length - 1); // trim off \n
+
+            
+            return buffer.position();
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+        errno(ENOENT);
+        return -1; // We tried and failed for some reason. Indicate error.
+    }
+
+    public Map<String, String> getEnv() {
+        return env;
+    }
+
+    public static FileDescriptor toFileDescriptor(int fileDescriptor) {
+        FileDescriptor descriptor = new FileDescriptor();
+        try {
+            ReflectiveAccess.FILE_DESCRIPTOR_FD.set(descriptor, fileDescriptor);
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+        return descriptor;
+    }
+
+    public static FileDescriptor toFileDescriptor(HANDLE fileDescriptor) {
+        FileDescriptor descriptor = new FileDescriptor();
+        try {
+            ReflectiveAccess.FILE_DESCRIPTOR_HANDLE.set(descriptor, fileDescriptor.toPointer().address());
+        } catch (IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+        return descriptor;
+    }
+
+    private static class PosixExec extends ExecIt {
+        private final AtomicReference<Errno> errno = new AtomicReference<Errno>(Errno.EINVAL);
+        private final ErrnoParsingOutputStream errorStream = new ErrnoParsingOutputStream(errno);
+
+        public PosixExec(POSIXHandler handler) {
+            super(handler);
+        }
+
+        private int parseResult(int result) {
+            if (result == 0) {
+                return result;
+            }
+            errno(errno.get());
+            return -1;
+        }
+
+        public int runAndWait(String... args) throws IOException, InterruptedException {
+            return runAndWait(handler.getOutputStream(), errorStream, args);
+        }
+
+        public int runAndWait(OutputStream output, String... args) throws IOException, InterruptedException {
+            return runAndWait(output, errorStream, args);
+        }
+
+        public int runAndWait(OutputStream output, OutputStream error, String... args) throws IOException, InterruptedException {
+            return parseResult(super.runAndWait(output, error, args));
+        }
+    }
+
+    private static final class ErrnoParsingOutputStream extends OutputStream {
+        private final ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        private final AtomicReference<Errno> errno;
+
+        private ErrnoParsingOutputStream(AtomicReference<Errno> errno) {
+            this.errno = errno;
+        }
+
+        @Override
+        public void write(int b) throws IOException {
+            if (b != '\r' && b != '\n' && b != -1) {
+                baos.write(b);
+            } else if (baos.size() > 0) {
+                String errorString = baos.toString();
+                baos.reset();
+                parseError(errorString);
+            }
+        }
+
+        static Map<Pattern, Errno> errorPatterns = new HashMap<Pattern, Errno>();
+        static {
+            errorPatterns.put(Pattern.compile("File exists"), Errno.EEXIST);
+            errorPatterns.put(Pattern.compile("Operation not permitted"), Errno.EPERM);
+            errorPatterns.put(Pattern.compile("No such file or directory"), Errno.ENOENT);
+            errorPatterns.put(Pattern.compile("Input/output error"), Errno.EIO);
+            errorPatterns.put(Pattern.compile("Not a directory"), Errno.ENOTDIR);
+            errorPatterns.put(Pattern.compile("No space left on device"), Errno.ENOSPC);
+            errorPatterns.put(Pattern.compile("Read-only file system"), Errno.EROFS);
+            errorPatterns.put(Pattern.compile("Too many links"), Errno.EMLINK);
+        }
+
+        void parseError(String errorString) {
+            for (Map.Entry<Pattern, Errno> entry : errorPatterns.entrySet()) {
+                if (entry.getKey().matcher(errorString).find()) {
+                    errno.set(entry.getValue());
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/java/jnr/posix/JavaPOSIX.java b/src/main/java/jnr/posix/JavaPOSIX.java
new file mode 100644
index 0000000..d934ebb
--- /dev/null
+++ b/src/main/java/jnr/posix/JavaPOSIX.java
@@ -0,0 +1,893 @@
+package jnr.posix;
+
+import jnr.constants.platform.Errno;
+import jnr.constants.platform.Fcntl;
+import jnr.constants.platform.Signal;
+import jnr.constants.platform.Sysconf;
+import jnr.ffi.Pointer;
+import jnr.posix.util.Java5ProcessMaker;
+import jnr.posix.util.MethodName;
+import jnr.posix.util.Platform;
+import jnr.posix.util.ProcessMaker;
+import jnr.posix.util.SunMiscSignal;
+
+import java.io.*;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.util.Collection;
+import java.util.Map;
+import jnr.constants.platform.Confstr;
+
+import static jnr.constants.platform.Errno.EINVAL;
+import static jnr.constants.platform.Errno.ENOENT;
+import jnr.constants.platform.Pathconf;
+
+final class JavaPOSIX implements POSIX {
+    private final POSIXHandler handler;
+    private final JavaLibCHelper helper;
+
+    JavaPOSIX(POSIXHandler handler) {
+        this.handler = handler;
+        this.helper = new JavaLibCHelper(handler);
+    }
+
+    public ProcessMaker newProcessMaker(String... command) {
+        return new Java5ProcessMaker(handler, command);
+    }
+
+    public ProcessMaker newProcessMaker() {
+        return new Java5ProcessMaker(handler);
+    }
+    
+    public FileStat allocateStat() {
+        return new JavaFileStat(this, handler);
+    }
+
+    public MsgHdr allocateMsgHdr() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return null;
+    }
+
+    public SocketMacros socketMacros() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return null;
+    }
+
+    public int chmod(String filename, int mode) {
+        return helper.chmod(filename, mode);
+    }
+
+    public int fchmod(int fd, int mode) {
+        handler.unimplementedError("No fchmod in Java (yet)");
+        return -1;
+    }
+
+    public int chown(String filename, int user, int group) {
+        return helper.chown(filename, user, group);
+    }
+
+    public int fchown(int fd, int user, int group) {
+        handler.unimplementedError("No fchown in Java (yet)");
+        return -1;
+    }
+
+    public CharSequence crypt(CharSequence key, CharSequence salt) {
+        return helper.crypt(key, salt);
+    }
+
+    public byte[] crypt(byte[] key, byte[] salt) {
+        return helper.crypt(key, salt);
+    }
+
+    public int exec(String path, String... argv) {
+        handler.unimplementedError("No exec in Java (yet)");
+        
+        return -1;
+    }
+
+    public int exec(String path, String[] argv, String[] envp) {
+        handler.unimplementedError("No exec in Java (yet)");
+        
+        return -1;
+    }
+    
+    public int execv(String path, String[] argv) {
+        handler.unimplementedError("No execv in Java (yet)");
+        
+        return -1;
+    }
+    
+    public int execve(String path, String[] argv, String[] envp) {
+        handler.unimplementedError("No execve in Java (yet)");
+        
+        return -1;
+    }
+    
+    public FileStat fstat(FileDescriptor descriptor) {
+        handler.unimplementedError("fstat unimplemented");
+        
+        return null;
+    }
+
+    public FileStat fstat(int descriptor) {
+        handler.unimplementedError("fstat unimplemented");
+        
+        return null;
+    }
+
+    public int fstat(int fd, FileStat stat) {
+        handler.unimplementedError("fstat unimplemented");
+        return -1;
+    }
+
+    public int fstat(FileDescriptor descriptor, FileStat stat) {
+        handler.unimplementedError("fstat unimplemented");
+        return -1;
+    }
+
+    public int getegid() {
+        return LoginInfo.GID;
+    }
+    
+    public int geteuid() {
+        return LoginInfo.UID;
+    }
+    
+    public int getgid() {
+        return LoginInfo.GID;
+    }
+
+    public int getdtablesize() {
+        handler.unimplementedError("getdtablesize unimplemented");
+        return -1;
+    }
+
+    public String getlogin() {
+        return helper.getlogin();
+    }
+
+    public int getpgid() {
+        return unimplementedInt("getpgid");
+    }
+
+    public int getpgrp() {
+        return unimplementedInt("getpgrp");
+    }
+
+    public int getpid() {
+        return helper.getpid();
+    }
+
+    public int getppid() {
+        return unimplementedInt("getppid");
+    }
+
+    public Passwd getpwent() {
+        return helper.getpwent();
+    }
+
+    public Passwd getpwuid(int which) {
+        return helper.getpwuid(which);
+    }
+
+    public Group getgrgid(int which) {
+        handler.unimplementedError("getgrgid unimplemented");
+        return null;
+    }
+
+    public Passwd getpwnam(String which) {
+        handler.unimplementedError("getpwnam unimplemented");
+        return null;
+    }
+    public Group getgrnam(String which) {
+        handler.unimplementedError("getgrnam unimplemented");
+        return null;
+    }
+
+    public Group getgrent() {
+        handler.unimplementedError("getgrent unimplemented");
+        return null;
+    }
+
+    public int setpwent() {
+        return helper.setpwent();
+    }
+
+    public int endpwent() {
+        return helper.endpwent();
+    }
+
+    public int setgrent() {
+        return unimplementedInt("setgrent");
+    }
+
+    public int endgrent() {
+        return unimplementedInt("endgrent");
+    }
+
+    public Pointer environ() {
+        handler.unimplementedError("environ");
+
+        return null;
+    }
+
+    // @see setenv for more on the environment methods
+    public String getenv(String envName) {
+        return helper.getEnv().get(envName);
+    }
+
+    public int getuid() {
+        return LoginInfo.UID;
+    }
+
+    public int getrlimit(int resource, RLimit rlim) {
+        return unimplementedInt("getrlimit");
+    }
+
+    public int getrlimit(int resource, Pointer rlim) {
+        return unimplementedInt("getrlimit");
+    }
+
+    public RLimit getrlimit(int resource) {
+        handler.unimplementedError("getrlimit");
+
+        return null;
+    }
+
+    public int setrlimit(int resource, RLimit rlim) {
+        return unimplementedInt("setrlimit");
+    }
+
+    public int setrlimit(int resource, Pointer rlim) {
+        return unimplementedInt("setrlimit");
+    }
+
+    public int setrlimit(int resource, long rlimCur, long rlimMax) {
+        return unimplementedInt("setrlimit");
+    }
+
+    public int fork() {
+        return -1;
+    }
+
+    public boolean isatty(FileDescriptor fd) {
+        return (fd == FileDescriptor.in
+                || fd == FileDescriptor.out
+                || fd == FileDescriptor.err);
+    }
+
+    public int isatty(int fd) {
+        return (fd == 0
+                || fd == 1
+                || fd == 2) ? 1 : 0;
+    }
+
+    public int kill(int pid, int signal) {
+        return unimplementedInt("kill");    // FIXME: Can be implemented
+    }
+
+    public int kill(long pid, int signal) {
+        return unimplementedInt("kill");    // FIXME: Can be implemented
+    }
+
+    public SignalHandler signal(Signal sig, SignalHandler handler) {
+        return SunMiscSignal.signal(sig, handler);
+    }
+
+    public int raise(int sig) {
+        return unimplementedInt("raise");
+    }
+
+    public int lchmod(String filename, int mode) {
+        return unimplementedInt("lchmod");    // FIXME: Can be implemented
+    }
+
+    public int lchown(String filename, int user, int group) {
+        return unimplementedInt("lchown");     // FIXME: Can be implemented
+    }
+
+    public int link(String oldpath, String newpath) {
+        return helper.link(oldpath, newpath);
+    }
+
+    public FileStat lstat(String path) {
+        FileStat stat = allocateStat();
+
+        if (lstat(path, stat) < 0) handler.error(ENOENT, "lstat", path);
+        
+        return stat;
+    }
+
+    public int lstat(String path, FileStat stat) {
+        return helper.lstat(path, stat);
+    }
+
+    public int mkdir(String path, int mode) {
+        return helper.mkdir(path, mode);
+    }
+
+    public int rmdir(String path) {
+        return helper.rmdir(path);
+    }
+
+    public String readlink(String path) throws IOException {
+        // TODO: this should not be hardcoded to 256 bytes
+        ByteBuffer buffer = ByteBuffer.allocateDirect(256);
+        int result = helper.readlink(path, buffer, buffer.capacity());
+        
+        if (result == -1) return null;
+        
+        buffer.position(0);
+        buffer.limit(result);
+        return Charset.forName("ASCII").decode(buffer).toString();
+    }
+
+    public int readlink(CharSequence path, byte[] buf, int bufsize) {
+        handler.unimplementedError("readlink");
+
+        return -1;
+    }
+
+    public int readlink(CharSequence path, ByteBuffer buf, int bufsize) {
+        handler.unimplementedError("readlink");
+
+        return -1;
+    }
+
+    public int readlink(CharSequence path, Pointer bufPtr, int bufsize) {
+        handler.unimplementedError("readlink");
+
+        return -1;
+    }
+
+    // At this point the environment is not being used by any methods here.
+    // getenv/setenv/unsetenv do behave properly via POSIX definitions, but 
+    // it is only a storage facility at the moment.  In a future release, this
+    // map will be hooked up to the methods which depend on env.
+    public int setenv(String envName, String envValue, int overwrite) {
+        Map<String, String> env = helper.getEnv();
+        
+        if (envName.contains("=")) {
+            handler.error(EINVAL, "setenv", envName);
+            return -1;
+        }
+        
+        // POSIX specified.  Existence is success if overwrite is 0.
+        if (overwrite == 0 && env.containsKey(envName)) return 0;
+        
+        env.put(envName, envValue);
+        
+        return 0;
+    }
+
+    public FileStat stat(String path) {
+        FileStat stat = allocateStat(); 
+
+        if (helper.stat(path, stat) < 0) handler.error(ENOENT, "stat", path);
+        
+        return stat;
+    }
+
+    public int stat(String path, FileStat stat) {
+        return helper.stat(path, stat);
+    }
+
+    public int symlink(String oldpath, String newpath) {
+        return helper.symlink(oldpath, newpath);
+    }
+
+    public int setegid(int egid) {
+        return unimplementedInt("setegid");
+    }
+
+    public int seteuid(int euid) {
+        return unimplementedInt("seteuid");
+    }
+
+    public int setgid(int gid) {
+        return unimplementedInt("setgid");
+    }
+
+    public int getpgid(int pid) {
+        return unimplementedInt("getpgid");
+    }
+
+    public int setpgid(int pid, int pgid) {
+        return unimplementedInt("setpgid");
+    }
+
+    public int setpgrp(int pid, int pgrp) {
+        return unimplementedInt("setpgrp");
+    }
+
+    public int setsid() {
+        return unimplementedInt("setsid");
+    }
+
+    public int setuid(int uid) {
+        return unimplementedInt("setuid");
+    }
+
+    public int umask(int mask) {
+        // TODO: We can possibly maintain an internal mask and try and apply it to individual
+        // libc methods.  
+        return 0;
+    }
+
+    public int unsetenv(String envName) {
+        if (helper.getEnv().remove(envName) == null) {
+            handler.error(EINVAL, "unsetenv", envName);
+            return -1;
+        }
+        
+        return 0;
+    }
+    
+    public int utimes(String path, long[] atimeval, long[] mtimeval) {
+        long mtimeMillis;
+        if (mtimeval != null) {
+            assert mtimeval.length == 2;
+            mtimeMillis = (mtimeval[0] * 1000) + (mtimeval[1] / 1000);
+        } else {
+            mtimeMillis = System.currentTimeMillis();
+        }
+        new File(path).setLastModified(mtimeMillis);
+        return 0;
+    }
+
+    public int utimes(String path, Pointer times) {
+        return unimplementedInt("utimes");
+    }
+
+    public int futimes(int fd, long[] atimeval, long[] mtimeval) {
+        handler.unimplementedError("futimes");
+        return unimplementedInt("futimes");
+    }
+
+    public int lutimes(String path, long[] atimeval, long[] mtimeval) {
+        handler.unimplementedError("lutimes");
+        return unimplementedInt("lutimes");
+    }
+
+    public int utimensat(int dirfd, String path, long[] atimespec, long[] mtimespec, int flag) {
+        long mtimeMillis;
+        if (mtimespec != null) {
+            assert mtimespec.length == 2;
+            mtimeMillis = (mtimespec[0] * 1000) + (mtimespec[1] / 1000000);
+        } else {
+            mtimeMillis = System.currentTimeMillis();
+        }
+        new File(path).setLastModified(mtimeMillis);
+        return 0;
+    }
+
+    public int utimensat(int dirfd, String path, Pointer times, int flag) {
+        return unimplementedInt("utimensat");
+    }
+
+    public int futimens(int fd, long[] atimespec, long[] mtimespec) {
+        handler.unimplementedError("futimens");
+        return unimplementedInt("futimens");
+    }
+
+    public int futimens(int fd, Pointer times) {
+        handler.unimplementedError("futimens");
+        return unimplementedInt("futimens");
+    }
+
+    public int wait(int[] status) {
+        return unimplementedInt("wait");
+    }
+    
+    public int waitpid(int pid, int[] status, int flags) {
+        return unimplementedInt("waitpid");
+    }
+
+    public int waitpid(long pid, int[] status, int flags) {
+        return unimplementedInt("waitpid");
+    }
+
+    public int getpriority(int which, int who) {
+        return unimplementedInt("getpriority");
+    }
+    
+    public int setpriority(int which, int who, int prio) {
+        return unimplementedInt("setpriority");
+    }
+
+    public long posix_spawnp(String path, Collection<? extends SpawnFileAction> fileActions, Collection<? extends CharSequence> argv, Collection<? extends CharSequence> envp) {
+        return unimplementedInt("posix_spawnp");
+    }
+
+    public long posix_spawnp(String path, Collection<? extends SpawnFileAction> fileActions,
+                             Collection<? extends SpawnAttribute> spawnAttributes,
+                             Collection<? extends CharSequence> argv, Collection<? extends CharSequence> envp) {
+        return unimplementedInt("posix_spawnp");
+    }
+
+    public int errno() {
+        return JavaLibCHelper.errno();
+    }
+
+    public void errno(int value) {
+        JavaLibCHelper.errno(value);
+    }
+    
+    public int chdir(String path) {
+        return JavaLibCHelper.chdir(path);
+    }
+
+    public boolean isNative() {
+        return false;
+    }
+
+    public LibC libc() {
+        return null;
+    }
+
+    private int unimplementedInt(String message) {
+        handler.unimplementedError(message);
+
+        return -1;
+    }
+
+    public long sysconf(Sysconf name) {
+        switch (name) {
+            case _SC_CLK_TCK:
+                return JavaTimes.HZ;
+
+            default:
+                errno(Errno.EOPNOTSUPP.intValue());
+                return -1;
+        }
+    }
+
+    public int confstr(Confstr name, ByteBuffer buf, int len) {
+        errno(Errno.EOPNOTSUPP.intValue());
+        return -1;
+    }
+
+    public int fpathconf(int fd, Pathconf name) {
+        errno(Errno.EOPNOTSUPP.intValue());
+        return -1;
+    }
+
+    public Times times() {
+        return new JavaTimes();
+    }
+    
+    public int flock(int fd, int mode) {
+        return unimplementedInt("flock");
+    }
+
+    public int dup(int fd) {
+        return unimplementedInt("dup");
+    }
+
+    public int dup2(int oldFd, int newFd) {
+        return unimplementedInt("dup2");
+    }
+
+    public int fcntlInt(int fd, Fcntl fcntlConst, int arg) {
+        return unimplementedInt("fcntl");
+    }
+
+    public int fcntl(int fd, Fcntl fcntlConst) {
+        return unimplementedInt("fcntl");
+    }
+
+    public int fcntl(int fd, Fcntl fcntlConst, int arg) {
+        return unimplementedInt("fcntl");
+    }
+
+    @Deprecated
+    public int fcntl(int fd, Fcntl fcntlConst, int... arg) {
+        return unimplementedInt("fcntl");
+    }
+
+    public int access(CharSequence path, int amode) {
+        handler.unimplementedError("access");
+
+        return -1;
+    }
+
+    public int close(int fd) {
+        return unimplementedInt("close");
+    }
+
+    public int unlink(CharSequence path) {
+        handler.unimplementedError("unlink");
+
+        return -1;
+    }
+
+    public int open(CharSequence path, int flags, int perm) {
+        handler.unimplementedError("open");
+
+        return -1;
+    }
+
+
+    public long read(int fd, byte[] buf, long n) {
+        handler.unimplementedError("read");
+
+        return -1;
+    }
+    public long write(int fd, byte[] buf, long n) {
+        handler.unimplementedError("write");
+
+        return -1;
+    }
+    public long read(int fd, ByteBuffer buf, long n) {
+        handler.unimplementedError("read");
+
+        return -1;
+    }
+    public long write(int fd, ByteBuffer buf, long n) {
+        handler.unimplementedError("write");
+
+        return -1;
+    }
+    public long pread(int fd, byte[] buf, long n, long offset) {
+        handler.unimplementedError("pread");
+
+        return -1;
+    }
+    public long pwrite(int fd, byte[] buf, long n, long offset) {
+        handler.unimplementedError("pwrite");
+
+        return -1;
+    }
+    public long pread(int fd, ByteBuffer buf, long n, long offset) {
+        handler.unimplementedError("pread");
+
+        return -1;
+    }
+    public long pwrite(int fd, ByteBuffer buf, long n, long offset) {
+        handler.unimplementedError("pwrite");
+
+        return -1;
+    }
+
+    public int read(int fd, byte[] buf, int n) {
+        handler.unimplementedError("read");
+
+        return -1;
+    }
+    public int write(int fd, byte[] buf, int n) {
+        handler.unimplementedError("write");
+
+        return -1;
+    }
+    public int read(int fd, ByteBuffer buf, int n) {
+        handler.unimplementedError("read");
+
+        return -1;
+    }
+    public int write(int fd, ByteBuffer buf, int n) {
+        handler.unimplementedError("write");
+
+        return -1;
+    }
+    public int pread(int fd, byte[] buf, int n, int offset) {
+        handler.unimplementedError("pread");
+
+        return -1;
+    }
+    public int pwrite(int fd, byte[] buf, int n, int offset) {
+        handler.unimplementedError("pwrite");
+
+        return -1;
+    }
+    public int pread(int fd, ByteBuffer buf, int n, int offset) {
+        handler.unimplementedError("pread");
+
+        return -1;
+    }
+    public int pwrite(int fd, ByteBuffer buf, int n, int offset) {
+        handler.unimplementedError("pwrite");
+
+        return -1;
+    }
+
+    public int lseek(int fd, long offset, int whence) {
+        handler.unimplementedError("lseek");
+
+        return -1;
+    }
+
+    public long lseekLong(int fd, long offset, int whence) {
+        handler.unimplementedError("lseek");
+
+        return -1;
+    }
+
+    public int pipe(int[] fds) {
+        handler.unimplementedError("pipe");
+
+        return -1;
+    }
+
+    public int socketpair(int domain, int type, int protocol, int[] fds) {
+        handler.unimplementedError("socketpair");
+
+        return -1;
+    }
+
+    public int sendmsg(int socket, MsgHdr message, int flags) {
+        handler.unimplementedError("sendmsg");
+
+        return -1;
+    }
+
+    public int recvmsg(int socket, MsgHdr message, int flags) {
+        handler.unimplementedError("recvmsg");
+
+        return -1;
+    }
+
+    public int truncate(CharSequence path, long length) {
+        handler.unimplementedError("truncate");
+
+        return -1;
+    }
+
+    public int ftruncate(int fd, long offset) {
+        handler.unimplementedError("ftruncate");
+
+        return -1;
+    }
+
+    public int rename(CharSequence oldName, CharSequence newName) {
+        // Very basic support.  This might not work well with rename's semantics regarding symlinks.
+
+        File oldFile = new File(oldName.toString());
+        File newFile = new File(newName.toString());
+
+        if (oldFile.renameTo(newFile)) {
+            return 0;
+        }
+
+        return -1;
+    }
+
+    public String getcwd() {
+        return System.getProperty("user.dir");
+    }
+
+    public int fsync(int fd) {
+        handler.unimplementedError("fsync");
+        return unimplementedInt("fsync not available for Java");
+    }
+
+    public int fdatasync(int fd) {
+        handler.unimplementedError("fdatasync");
+        return unimplementedInt("fdatasync not available for Java");
+    }
+
+    public int mkfifo(String filename, int mode) {
+        handler.unimplementedError("mkfifo");
+        return unimplementedInt("mkfifo not available for Java");
+    }
+
+    public int daemon(int nochdir, int noclose) {
+        handler.unimplementedError("daemon");
+        return unimplementedInt("daemon not available for Java");
+    }
+
+    public long[] getgroups() {
+        handler.unimplementedError("getgroups");
+        return null;
+    }
+
+    public int getgroups(int size, int[] groups) {
+        handler.unimplementedError("getgroups");
+        return unimplementedInt("getgroups not available for Java");
+    }
+
+    public String nl_langinfo(int item) {
+        handler.unimplementedError("nl_langinfo");
+        return null;
+    }
+
+    public String setlocale(int category, String locale) {
+        handler.unimplementedError("setlocale");
+        return null;
+    }
+
+    @Override
+    public String strerror(int code) {
+        handler.unimplementedError("strerror");
+        return null;
+    }
+
+    public Timeval allocateTimeval() {
+        handler.unimplementedError("allocateTimeval");
+        return null;
+    }
+
+    @Override
+    public int gettimeofday(Timeval tv) {
+        handler.unimplementedError("gettimeofday");
+        return -1;
+    }
+
+    public String gethostname() {
+        return helper.gethostname();
+    }
+
+    static final class LoginInfo {
+        public static final int UID = IDHelper.getInt("-u");
+        public static final int GID = IDHelper.getInt("-g");
+        public static final String USERNAME = IDHelper.getString("-un");
+    }
+    private static final class IDHelper {
+        private static final String ID_CMD = Platform.IS_SOLARIS ? "/usr/xpg4/bin/id" : "/usr/bin/id";
+        private static final int NOBODY = Platform.IS_WINDOWS ? 0 : Short.MAX_VALUE;
+        public static int getInt(String option) {
+            try {
+                Process p = Runtime.getRuntime().exec(new String[] { ID_CMD, option });
+                BufferedReader r = new BufferedReader(new InputStreamReader(p.getInputStream()));
+                return Integer.parseInt(r.readLine());
+            } catch (IOException ex) {
+                return NOBODY;
+            } catch (NumberFormatException ex) {
+                return NOBODY;
+            } catch (SecurityException ex) {
+                return NOBODY;
+            }
+        }
+        public static String getString(String option) {
+            try {
+                Process p = Runtime.getRuntime().exec(new String[] { ID_CMD, option });
+                BufferedReader r = new BufferedReader(new InputStreamReader(p.getInputStream()));
+                return r.readLine();
+            } catch (IOException ex) {
+                return null;
+            }
+        }
+    }
+    private static final class FakePasswd implements Passwd {
+
+        public String getLoginName() {
+            return LoginInfo.USERNAME;
+        }
+
+        public String getPassword() {
+            return "";
+        }
+
+        public long getUID() {
+            return LoginInfo.UID;
+        }
+
+        public long getGID() {
+            return LoginInfo.GID;
+        }
+
+        public int getPasswdChangeTime() {
+            return 0;
+        }
+
+        public String getAccessClass() {
+            return "";
+        }
+
+        public String getGECOS() {
+            return getLoginName();
+        }
+
+        public String getHome() {
+            return "/";
+        }
+
+        public String getShell() {
+            return "/bin/sh";
+        }
+
+        public int getExpire() {
+            return ~0;
+        }
+
+    }
+}
diff --git a/src/main/java/jnr/posix/JavaPasswd.java b/src/main/java/jnr/posix/JavaPasswd.java
new file mode 100644
index 0000000..cfd37b3
--- /dev/null
+++ b/src/main/java/jnr/posix/JavaPasswd.java
@@ -0,0 +1,59 @@
+package jnr.posix;
+
+final class JavaPasswd implements Passwd {
+    private final POSIXHandler handler;
+
+    public JavaPasswd(POSIXHandler handler) {
+        this.handler = handler;
+    }
+    
+    public String getAccessClass() {
+        handler.unimplementedError("passwd.pw_access unimplemented");
+        
+        return null;
+    }
+
+    public String getGECOS() {
+        return getLoginName();
+    }
+
+    public long getGID() {
+        return JavaPOSIX.LoginInfo.GID;
+    }
+
+    public String getHome() {
+        return System.getProperty("user.home");
+    }
+
+    public String getLoginName() {
+        return System.getProperty("user.name");
+    }
+
+    public int getPasswdChangeTime() {
+        handler.unimplementedError("passwd.pw_change unimplemented");
+
+        return 0;
+    }
+
+    public String getPassword() {
+        handler.unimplementedError("passwd.pw_passwd unimplemented");
+        
+        return null;
+    }
+
+    public String getShell() {
+        handler.unimplementedError("passwd.pw_env unimplemented");
+        
+        return null;
+    }
+
+    public long getUID() {
+        return JavaPOSIX.LoginInfo.UID;
+    }
+
+    public int getExpire() {
+        handler.unimplementedError("passwd.expire unimplemented");
+        
+        return ~0;
+    }
+}
diff --git a/src/main/java/jnr/posix/JavaSecuredFile.java b/src/main/java/jnr/posix/JavaSecuredFile.java
new file mode 100644
index 0000000..b7d9295
--- /dev/null
+++ b/src/main/java/jnr/posix/JavaSecuredFile.java
@@ -0,0 +1,256 @@
+/**
+ * ** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ * <p/>
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ * <p/>
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * <p/>
+ * <p/>
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ * **** END LICENSE BLOCK ****
+ */
+
+package jnr.posix;
+
+import java.io.File;
+import java.io.FileFilter;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.net.URI;
+
+@SuppressWarnings("serial")
+public class JavaSecuredFile extends File {
+
+    public JavaSecuredFile(String pathname) {
+        super(pathname);
+    }
+
+    public JavaSecuredFile(String parent, String child) {
+        super(parent, child);
+    }
+
+    public JavaSecuredFile(File parent, String child) {
+        super(parent, child);
+    }
+
+    public JavaSecuredFile(URI uri) {
+        super(uri);
+    }
+
+
+    @Override
+    public File getParentFile() {
+        String path = getParent();
+        return path == null ? null : new JavaSecuredFile(path);
+    }
+
+    @Override
+    public File getAbsoluteFile() {
+        String path = getAbsolutePath();
+        return path == null ? null : new JavaSecuredFile(path);
+    }
+
+    @Override
+    public File getCanonicalFile() throws IOException {
+        String path = getCanonicalPath();
+        return path == null ? null : new JavaSecuredFile(path);
+    }
+
+    @Override
+    public boolean canRead() {
+        try {
+            return super.canRead();
+        } catch (SecurityException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean canWrite() {
+        try {
+            return super.canWrite();
+        } catch (SecurityException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean exists() {
+        try {
+            return super.exists();
+        } catch (SecurityException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean isDirectory() {
+        try {
+            return super.isDirectory();
+        } catch (SecurityException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean isFile() {
+        try {
+            return super.isFile();
+        } catch (SecurityException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean isHidden() {
+        try {
+            return super.isHidden();
+        } catch (SecurityException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean delete() {
+        try {
+            return super.delete();
+        } catch (SecurityException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean mkdir() {
+        try {
+            return super.mkdir();
+        } catch (SecurityException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean mkdirs() {
+        try {
+            return super.mkdirs();
+        } catch (SecurityException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean renameTo(File dest) {
+        try {
+            return super.renameTo(dest);
+        } catch (SecurityException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean setLastModified(long time) {
+        try {
+            return super.setLastModified(time);
+        } catch (SecurityException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean setReadOnly() {
+        try {
+            return super.setReadOnly();
+        } catch (SecurityException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public String getCanonicalPath() throws IOException {
+        try {
+            return super.getCanonicalPath();
+        } catch (SecurityException e) {
+            throw new IOException(e);
+        }
+    }
+
+    @Override
+    public boolean createNewFile() throws IOException {
+        try {
+            return super.createNewFile();
+        } catch (SecurityException e) {
+            throw new IOException(e);
+        }
+    }
+
+    @Override
+    public String[] list() {
+        try {
+            return super.list();
+        } catch (SecurityException e) {
+            return null;
+        }
+    }
+
+    @Override
+    public String[] list(FilenameFilter filter) {
+        try {
+            return super.list(filter);
+        } catch (SecurityException e) {
+            return null;
+        }
+    }
+
+    @Override
+    public File[] listFiles() {
+        try {
+            return super.listFiles();
+        } catch (SecurityException e) {
+            return null;
+        }
+    }
+
+    @Override
+    public File[] listFiles(FileFilter filter) {
+        try {
+            return super.listFiles(filter);
+        } catch (SecurityException e) {
+            return null;
+        }
+    }
+
+    @Override
+    public long lastModified() {
+        try {
+            return super.lastModified();
+        } catch (SecurityException e) {
+            return 0L;
+        }
+    }
+
+    @Override
+    public long length() {
+        try {
+            return super.length();
+        } catch (SecurityException e) {
+            return 0L;
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/jnr/posix/JavaTimes.java b/src/main/java/jnr/posix/JavaTimes.java
new file mode 100644
index 0000000..44cb0d1
--- /dev/null
+++ b/src/main/java/jnr/posix/JavaTimes.java
@@ -0,0 +1,22 @@
+package jnr.posix;
+
+final class JavaTimes implements Times {
+    private static final long startTime = System.currentTimeMillis();
+    static final long HZ = 1000;
+
+    public long utime() {
+        return Math.max(System.currentTimeMillis() - startTime, 1);
+    }
+
+    public long stime() {
+        return 0;
+    }
+
+    public long cutime() {
+        return 0;
+    }
+
+    public long cstime() {
+        return 0;
+    }
+}
diff --git a/src/main/java/jnr/posix/LazyPOSIX.java b/src/main/java/jnr/posix/LazyPOSIX.java
new file mode 100644
index 0000000..14d5213
--- /dev/null
+++ b/src/main/java/jnr/posix/LazyPOSIX.java
@@ -0,0 +1,635 @@
+
+package jnr.posix;
+
+import jnr.constants.platform.Fcntl;
+import jnr.constants.platform.Sysconf;
+import jnr.ffi.Pointer;
+import jnr.posix.util.ProcessMaker;
+
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import jnr.constants.platform.Confstr;
+import jnr.constants.platform.Pathconf;
+import jnr.constants.platform.Signal;
+
+final class LazyPOSIX implements POSIX {
+
+    private final POSIXHandler handler;
+    private final boolean useNativePosix;
+
+    // NOTE: because all implementations of POSIX that are loaded via loadPOSIX()
+    // are immutable, there is no need for 'posix' to be a volatile field.
+    // See http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
+    // (but since volatile reads on x86 and x86_64 are cheap, do it anyway)
+    private volatile POSIX posix;
+
+    LazyPOSIX(POSIXHandler handler, boolean useNativePosix) {
+        this.handler = handler;
+        this.useNativePosix = useNativePosix;
+    }
+
+    private final POSIX posix() {
+        return posix != null ? posix : loadPOSIX();
+    }
+
+    private final synchronized POSIX loadPOSIX() {
+        return posix != null
+                ? posix
+                : (posix = POSIXFactory.loadPOSIX(handler, useNativePosix));
+    }
+
+    public ProcessMaker newProcessMaker(String... command) {
+        return posix().newProcessMaker(command);
+    }
+
+    public ProcessMaker newProcessMaker() {
+        return posix().newProcessMaker();
+    }
+    
+    public FileStat allocateStat() {
+        return posix().allocateStat();
+    }
+
+    public MsgHdr allocateMsgHdr() {
+        return posix().allocateMsgHdr();
+    }
+
+    public int chdir(String path) {
+        return posix().chdir(path);
+    }
+
+    public int chmod(String filename, int mode) {
+        return posix().chmod(filename, mode);
+    }
+
+    public int fchmod(int fd, int mode) {
+        return posix().fchmod(fd, mode);
+    }
+
+    public int chown(String filename, int user, int group) {
+        return posix().chown(filename, user, group);
+    }
+
+    public CharSequence crypt(CharSequence key, CharSequence salt) {
+        return posix().crypt(key, salt);
+    }
+
+    public byte[] crypt(byte[] key, byte[] salt) {
+        return posix().crypt(key, salt);
+    }
+
+    public int fchown(int fd, int user, int group) {
+        return posix().fchown(fd, user, group);
+    }
+
+    public int endgrent() {
+        return posix().endgrent();
+    }
+
+    public int endpwent() {
+        return posix().endpwent();
+    }
+
+    public int errno() {
+        return posix().errno();
+    }
+
+    public void errno(int value) {
+        posix().errno(value);
+    }
+    
+    public int exec(String path, String... args) {
+        return posix().exec(path, args);
+    }
+    
+    public int exec(String path, String[] args, String[] envp) {
+        return posix().exec(path, args, envp);
+    }
+
+    public int execv(String path, String[] argv) {
+        return posix().execv(path, argv);
+    }
+
+    public int execve(String path, String[] argv, String[] envp) {
+        return posix().execve(path, argv, envp);
+    }
+    
+    public int fork() {
+        return posix().fork();
+    }
+
+    public FileStat fstat(int fd) {
+        return posix().fstat(fd);
+    }
+
+    public int fstat(int fd, FileStat stat) {
+        return posix().fstat(fd, stat);
+    }
+
+    public FileStat fstat(FileDescriptor descriptor) {
+        return posix().fstat(descriptor);
+    }
+
+    public int fstat(FileDescriptor descriptor, FileStat stat) {
+        return posix().fstat(descriptor, stat);
+    }
+
+    public int getegid() {
+        return posix().getegid();
+    }
+
+    public int geteuid() {
+        return posix().geteuid();
+    }
+
+    public int getgid() {
+        return posix().getgid();
+    }
+
+    public int getdtablesize() {
+        return posix().getdtablesize();
+    }
+
+    public Group getgrent() {
+        return posix().getgrent();
+    }
+
+    public Group getgrgid(int which) {
+        return posix().getgrgid(which);
+    }
+
+    public Group getgrnam(String which) {
+        return posix().getgrnam(which);
+    }
+
+    public String getlogin() {
+        return posix().getlogin();
+    }
+
+    public int getpgid() {
+        return posix().getpgid();
+    }
+
+    public int getpgid(int pid) {
+        return posix().getpgid(pid);
+    }
+
+    public int getpgrp() {
+        return posix().getpgrp();
+    }
+
+    public int getpid() {
+        return posix().getpid();
+    }
+
+    public int getppid() {
+        return posix().getppid();
+    }
+
+    public int getpriority(int which, int who) {
+        return posix().getpriority(which, who);
+    }
+
+    public Passwd getpwent() {
+        return posix().getpwent();
+    }
+
+    public Passwd getpwnam(String which) {
+        return posix().getpwnam(which);
+    }
+
+    public Passwd getpwuid(int which) {
+        return posix().getpwuid(which);
+    }
+
+    public int getuid() {
+        return posix().getuid();
+    }
+
+    public int getrlimit(int resource, RLimit rlim) {
+        return posix().getrlimit(resource, rlim);
+    }
+
+    public int getrlimit(int resource, Pointer rlim) {
+        return posix().getrlimit(resource, rlim);
+    }
+
+    public RLimit getrlimit(int resource) {
+        return posix().getrlimit(resource);
+    }
+
+    public int setrlimit(int resource, RLimit rlim) {
+        return posix().setrlimit(resource, rlim);
+    }
+
+    public int setrlimit(int resource, Pointer rlim) {
+        return posix().setrlimit(resource, rlim);
+    }
+
+    public int setrlimit(int resource, long rlimCur, long rlimMax) {
+        return posix().setrlimit(resource, rlimCur, rlimMax);
+    }
+
+    public boolean isatty(FileDescriptor descriptor) {
+        return posix().isatty(descriptor);
+    }
+
+    public int isatty(int descriptor) {
+        return posix().isatty(descriptor);
+    }
+
+    public int kill(int pid, int signal) {
+        return kill((long) pid, signal);
+    }
+
+    public int kill(long pid, int signal) {
+        return posix().kill(pid, signal);
+    }
+    
+    public SignalHandler signal(Signal sig, SignalHandler handler) {
+        return posix().signal(sig, handler);
+    }
+
+    public int raise(int sig) {
+        return posix().raise(sig);
+    }
+
+    public int lchmod(String filename, int mode) {
+        return posix().lchmod(filename, mode);
+    }
+
+    public int lchown(String filename, int user, int group) {
+        return posix().lchown(filename, user, group);
+    }
+
+    public int link(String oldpath, String newpath) {
+        return posix().link(oldpath, newpath);
+    }
+
+    public FileStat lstat(String path) {
+        return posix().lstat(path);
+    }
+
+    public int lstat(String path, FileStat stat) {
+        return posix().lstat(path, stat);
+    }
+
+    public int mkdir(String path, int mode) {
+        return posix().mkdir(path, mode);
+    }
+
+    public String readlink(String path) throws IOException {
+        return posix().readlink(path);
+    }
+
+    public int readlink(CharSequence path, byte[] buf, int bufsize) {
+        return posix().readlink(path, buf, bufsize);
+    }
+
+    public int readlink(CharSequence path, ByteBuffer buf, int bufsize) {
+        return posix().readlink(path, buf, bufsize);
+    }
+
+    public int readlink(CharSequence path, Pointer bufPtr, int bufsize) {
+        return posix().readlink(path, bufPtr, bufsize);
+    }
+
+    public int rmdir(String path) {
+        return posix().rmdir(path);
+    }
+
+    public int setegid(int egid) {
+        return posix().setegid(egid);
+    }
+
+    public int seteuid(int euid) {
+        return posix().seteuid(euid);
+    }
+
+    public int setgid(int gid) {
+        return posix().setgid(gid);
+    }
+
+    public int setgrent() {
+        return posix().setgrent();
+    }
+
+    public int setpgid(int pid, int pgid) {
+        return posix().setpgid(pid, pgid);
+    }
+
+    public int setpgrp(int pid, int pgrp) {
+        return posix().setpgrp(pid, pgrp);
+    }
+
+    public int setpriority(int which, int who, int prio) {
+        return posix().setpriority(which, who, prio);
+    }
+
+    public int setpwent() {
+        return posix().setpwent();
+    }
+
+    public int setsid() {
+        return posix().setsid();
+    }
+
+    public int setuid(int uid) {
+        return posix().setuid(uid);
+    }
+
+    public FileStat stat(String path) {
+        return posix().stat(path);
+    }
+
+    public int stat(String path, FileStat stat) {
+        return posix().stat(path, stat);
+    }
+
+    public int symlink(String oldpath, String newpath) {
+        return posix().symlink(oldpath, newpath);
+    }
+
+    public int umask(int mask) {
+        return posix().umask(mask);
+    }
+
+    public int utimes(String path, long[] atimeval, long[] mtimeval) {
+        return posix().utimes(path, atimeval, mtimeval);
+    }
+
+    public int utimes(String path, Pointer times) {
+        return posix().utimes(path, times);
+    }
+
+    public int futimes(int fd, long[] atimeval, long[] mtimeval) {
+        return posix().futimes(fd, atimeval, mtimeval);
+    }
+
+    public int lutimes(String path, long[] atimeval, long[] mtimeval) {
+        return posix().lutimes(path, atimeval, mtimeval);
+    }
+
+    public int utimensat(int dirfd, String path, long[] atimespec, long[] mtimespec, int flag) {
+        return posix().utimensat(dirfd, path, atimespec, mtimespec, flag);
+    }
+
+    public int utimensat(int dirfd, String path, Pointer times, int flag) {
+        return posix().utimensat(dirfd, path, times, flag);
+    }
+
+    public int futimens(int fd, long[] atimespec, long[] mtimespec) {
+        return posix().futimens(fd, atimespec, mtimespec);
+    }
+
+    public int futimens(int fd, Pointer times) {
+        return posix().futimens(fd, times);
+    }
+
+    public int wait(int[] status) {
+        return posix().wait(status);
+    }
+
+    public int waitpid(int pid, int[] status, int flags) {
+        return waitpid((long) pid, status, flags);
+    }
+
+    public int waitpid(long pid, int[] status, int flags) {
+        return posix().waitpid(pid, status, flags);
+    }
+
+    public boolean isNative() {
+        return posix().isNative();
+    }
+
+    public LibC libc() {
+        return posix().libc();
+    }
+
+    public Pointer environ() {
+        return posix().environ();
+    }
+
+    public String getenv(String envName) {
+        return posix().getenv(envName);
+    }
+
+    public int setenv(String envName, String envValue, int overwrite) {
+        return posix().setenv(envName, envValue, overwrite);
+    }
+
+    public int unsetenv(String envName) {
+        return posix().unsetenv(envName);
+    }
+
+    public long posix_spawnp(String path, Collection<? extends SpawnFileAction> fileActions, Collection<? extends CharSequence> argv, Collection<? extends CharSequence> envp) {
+        return posix().posix_spawnp(path, fileActions, argv, envp);
+    }
+
+    public long posix_spawnp(String path, Collection<? extends SpawnFileAction> fileActions,
+                             Collection<? extends SpawnAttribute> spawnAttributes,
+                             Collection<? extends CharSequence> argv, Collection<? extends CharSequence> envp) {
+        return posix().posix_spawnp(path, fileActions, spawnAttributes, argv, envp);
+    }
+
+    public long sysconf(Sysconf name) {
+        return posix().sysconf(name);
+    }
+
+    public int confstr(Confstr name, ByteBuffer buf, int len) {
+        return posix().confstr(name, buf, len);
+    }
+
+    public int fpathconf(int fd, Pathconf name) {
+        return posix().fpathconf(fd, name);
+    }
+
+    public Times times() {
+        return posix().times();
+    }
+    
+    public int flock(int fd, int mode) {
+        return posix().flock(fd, mode);
+    }
+
+    public int dup(int fd) {
+        return posix().dup(fd);
+    }
+
+    public int dup2(int oldFd, int newFd) {
+        return posix().dup2(oldFd, newFd);
+    }
+
+    public int fcntlInt(int fd, Fcntl fcntlConst, int arg) {
+        return posix().fcntlInt(fd, fcntlConst, arg);
+    }
+
+    public int fcntl(int fd, Fcntl fcntlConst) {
+        return posix().fcntl(fd, fcntlConst);
+    }
+
+    public int fcntl(int fd, Fcntl fcntlConst, int arg) {
+        return posix().fcntl(fd, fcntlConst, arg);
+    }
+
+    @Deprecated
+    public int fcntl(int fd, Fcntl fcntlConst, int... arg) {
+        return posix().fcntl(fd, fcntlConst);
+    }
+
+    public int access(CharSequence path, int amode) {
+        return posix().access(path, amode);
+    }
+
+    public int close(int fd) {
+        return posix().close(fd);
+    }
+
+    public int unlink(CharSequence path) {
+        return posix().unlink(path);
+    }
+
+    public int open(CharSequence path, int flags, int perm) {
+        return posix().open(path, flags, perm);
+    }
+
+    public long read(int fd, byte[] buf, long n) {
+        return posix().read(fd, buf, n);
+    }
+    public long write(int fd, byte[] buf, long n) {
+        return posix().write(fd, buf, n);
+    }
+    public long read(int fd, ByteBuffer buf, long n) {
+        return posix().read(fd, buf, n);
+    }
+    public long write(int fd, ByteBuffer buf, long n) {
+        return posix().write(fd, buf, n);
+    }
+    public long pread(int fd, byte[] buf, long n, long offset) {
+        return posix().pread(fd, buf, n, offset);
+    }
+    public long pwrite(int fd, byte[] buf, long n, long offset) {
+        return posix().pwrite(fd, buf, n, offset);
+    }
+    public long pread(int fd, ByteBuffer buf, long n, long offset) {
+        return posix().pread(fd, buf, n, offset);
+    }
+    public long pwrite(int fd, ByteBuffer buf, long n, long offset) {
+        return posix().pwrite(fd, buf, n, offset);
+    }
+
+    public int read(int fd, byte[] buf, int n)
+    {
+        return posix().read(fd, buf, n);
+    }
+    public int write(int fd, byte[] buf, int n) {
+        return posix().write(fd, buf, n);
+    }
+    public int read(int fd, ByteBuffer buf, int n) {
+        return posix().read(fd, buf, n);
+    }
+    public int write(int fd, ByteBuffer buf, int n) {
+        return posix().write(fd, buf, n);
+    }
+    public int pread(int fd, byte[] buf, int n, int offset) {
+        return posix().pread(fd, buf, n, offset);
+    }
+    public int pwrite(int fd, byte[] buf, int n, int offset) {
+        return posix().pwrite(fd, buf, n, offset);
+    }
+    public int pread(int fd, ByteBuffer buf, int n, int offset) {
+        return posix().pread(fd, buf, n, offset);
+    }
+    public int pwrite(int fd, ByteBuffer buf, int n, int offset) {
+        return posix().pwrite(fd, buf, n, offset);
+    }
+
+    public int lseek(int fd, long offset, int whence) {
+        return posix().lseek(fd, offset, whence);
+    }
+
+    public long lseekLong(int fd, long offset, int whence) {
+        return posix().lseekLong(fd, offset, whence);
+    }
+
+    public int pipe(int[] fds) {
+        return posix().pipe(fds);
+    }
+
+    public int socketpair(int domain, int type, int protocol, int[] fds) {
+        return posix().socketpair(domain, type, protocol, fds);
+    }
+
+    public int sendmsg(int socket, MsgHdr message, int flags) {
+        return posix().sendmsg(socket, message, flags);
+    }
+
+    public int recvmsg(int socket, MsgHdr message, int flags) {
+        return posix().recvmsg(socket, message, flags);
+    }
+
+    public int truncate(CharSequence path, long length) {
+        return posix().truncate(path, length);
+    }
+
+    public int ftruncate(int fd, long offset) {
+        return posix().ftruncate(fd, offset);
+    }
+
+    public int rename(CharSequence oldName, CharSequence newName) {
+        return posix().rename(oldName, newName);
+    }
+
+    public String getcwd() {
+        return posix().getcwd();
+    }
+
+    public int fsync(int fd) {
+        return posix().fsync(fd);
+    }
+
+    public int fdatasync(int fd) {
+        return posix().fdatasync(fd);
+    }
+
+    public int mkfifo(String path, int mode) {
+        return posix().mkfifo(path, mode);
+    }
+
+    public String gethostname() {
+        return posix().gethostname();
+    }
+
+    public int daemon(int nochdir, int noclose) {
+        return posix().daemon(nochdir, noclose);
+    }
+
+    public long[] getgroups() {
+        return posix().getgroups();
+    }
+
+    public int getgroups(int size, int[] groups) {
+        return posix().getgroups(size, groups);
+    }
+
+    public String nl_langinfo(int item) {
+        return posix().nl_langinfo(item);
+    }
+
+    public String setlocale(int category, String locale) {
+        return posix().setlocale(category, locale);
+    }
+
+    @Override
+    public String strerror(int code) {
+        return posix().strerror(code);
+    }
+
+    @Override
+    public Timeval allocateTimeval() { return posix().allocateTimeval(); }
+
+    @Override
+    public int gettimeofday(Timeval tv) { return posix().gettimeofday(tv); }
+}
diff --git a/src/main/java/jnr/posix/LibC.java b/src/main/java/jnr/posix/LibC.java
new file mode 100644
index 0000000..fb384e7
--- /dev/null
+++ b/src/main/java/jnr/posix/LibC.java
@@ -0,0 +1,207 @@
+/*
+ **** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Copyright (C) 2007 Thomas E Enebo <enebo@acm.org>
+ * Copyright (C) 2007 Charles O Nutter <headius@headius.com>
+ * 
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+package jnr.posix;
+
+import jnr.constants.platform.Sysconf;
+import jnr.ffi.Pointer;
+import jnr.ffi.Variable;
+import jnr.ffi.annotations.*;
+import jnr.ffi.types.*;
+
+import java.nio.ByteBuffer;
+import jnr.constants.platform.Confstr;
+import jnr.constants.platform.Pathconf;
+import jnr.ffi.byref.IntByReference;
+
+public interface LibC {
+    int chmod(CharSequence filename, int mode);
+    int fchmod(int fd, int mode);
+    int chown(CharSequence filename, int user, int group);
+    int fchown(int fd, int user, int group);
+    int fstat(int fd, @Out @Transient FileStat stat);
+    int fstat64(int fd, @Out @Transient FileStat stat);
+    String getenv(CharSequence envName);
+    @IgnoreError int getegid();
+    int setegid(int egid);
+    @IgnoreError int geteuid();
+    int seteuid(int euid);
+    @IgnoreError int getgid();
+    String getlogin();
+    int setgid(int gid);
+    int getpgid();
+    int getpgid(int pid);
+    int setpgid(int pid, int pgid);
+    int getpgrp();
+    int setpgrp(int pid, int pgrp);
+    @IgnoreError int getppid();
+    @IgnoreError int getpid();
+    NativePasswd getpwent();
+    NativePasswd getpwuid(int which);
+    NativePasswd getpwnam(CharSequence which);
+    NativeGroup getgrent();
+    NativeGroup getgrgid(int which);
+    NativeGroup getgrnam(CharSequence which);
+    int setpwent();
+    int endpwent();
+    int setgrent();
+    int endgrent();
+    @IgnoreError int getuid();
+    int setsid();
+    int setuid(int uid);
+    int getrlimit(int resource, @Out RLimit rlim);
+    int getrlimit(int resource, Pointer rlim);
+    int setrlimit(int resource, @In RLimit rlim);
+    int setrlimit(int resource, Pointer rlim);
+    int kill(int pid, int signal);
+    int kill(long pid, int signal);
+
+    int dup(int fd);
+    int dup2(int oldFd, int newFd);
+
+    @Variadic(fixedCount = 2)
+    int fcntl(int fd, int fnctl, Flock arg);
+    @Variadic(fixedCount = 2)
+    int fcntl(int fd, int fnctl, Pointer arg);
+    @Variadic(fixedCount = 2)
+    int fcntl(int fd, int fnctl);
+    @Variadic(fixedCount = 2)
+    int fcntl(int fd, int fnctl, @u_int64_t int arg);
+    @Deprecated
+    int fcntl(int fd, int fnctl, int... arg);
+    int access(CharSequence path, int amode);
+    int getdtablesize();
+
+    public interface LibCSignalHandler {
+        @Delegate void signal(int sig);
+    }
+    @intptr_t long signal(int sig, LibCSignalHandler handler);
+    int raise(int raise);
+    int lchmod(CharSequence filename, int mode);
+    int lchown(CharSequence filename, int user, int group);
+    int link(CharSequence oldpath, CharSequence newpath);
+    int lstat(CharSequence path, @Out @Transient FileStat stat);
+    int lstat64(CharSequence path, @Out @Transient FileStat stat);
+    int mkdir(CharSequence path, int mode);
+    int rmdir(CharSequence path);
+    int stat(CharSequence path, @Out @Transient FileStat stat);
+    int stat64(CharSequence path, @Out @Transient FileStat stat);
+    int symlink(CharSequence oldpath, CharSequence newpath);
+    int readlink(CharSequence oldpath, @Out ByteBuffer buffer, int len);
+    int readlink(CharSequence path, @Out byte[] buffer, int len);
+    int readlink(CharSequence path, Pointer bufPtr, int bufsize);
+    int setenv(CharSequence envName, CharSequence envValue, int overwrite);
+    @IgnoreError int umask(int mask);
+    int unsetenv(CharSequence envName);
+    int utimes(CharSequence path, @In Timeval[] times);
+    int utimes(String path, @In Pointer times);
+    int futimes(int fd, @In Timeval[] times);
+    int lutimes(CharSequence path, @In Timeval[] times);
+    int utimensat(int dirfd, String path, Timespec[] times, int flag);
+    int utimensat(int dirfd, String path, @In Pointer times, int flag);
+    int futimens(int fd, Timespec[] times);
+    int futimens(int fd, @In Pointer times);
+    int fork();
+    int waitpid(long pid, @Out int[] status, int options);
+    int wait(@Out int[] status);
+    int getpriority(int which, int who);
+    int setpriority(int which, int who, int prio);
+    @IgnoreError int isatty(int fd);
+
+    @ssize_t long read(int fd, @Out byte[] dst, @size_t long len);
+    @ssize_t long write(int fd, @In byte[] src, @size_t long len);
+    @ssize_t long read(int fd, @Out ByteBuffer dst, @size_t long len);
+    @ssize_t long write(int fd, @In ByteBuffer src, @size_t long len);
+    @ssize_t long pread(int fd, @Out byte[] dst, @size_t long len, @off_t long offset);
+    @ssize_t long pwrite(int fd, @In byte[] src, @size_t long len, @off_t long offset);
+    @ssize_t long pread(int fd, @Out ByteBuffer dst, @size_t long len, @off_t long offset);
+    @ssize_t long pwrite(int fd, @In ByteBuffer src, @size_t long len, @off_t long offset);
+
+    int read(int fd, @Out byte[] dst, int len);
+    int write(int fd, @In byte[] src, int len);
+    int read(int fd, @Out ByteBuffer dst, int len);
+    int write(int fd, @In ByteBuffer src, int len);
+    int pread(int fd, @Out byte[] dst, int len, int offset);
+    int pwrite(int fd, @In byte[] src, int len, int offset);
+    int pread(int fd, @Out ByteBuffer dst, int len, int offset);
+    int pwrite(int fd, @In ByteBuffer src, int len, int offset);
+
+    long lseek(int fd, long offset, int whence);
+    int close(int fd);
+    int execv(CharSequence path, @In CharSequence[] argv);
+    int execve(CharSequence path, @In CharSequence[] argv, @In CharSequence[] envp);
+    int chdir(CharSequence path);
+
+    public long sysconf(Sysconf name);
+
+    public int confstr(Confstr name, @Out ByteBuffer buf, int len);
+
+    public int fpathconf(int fd, Pathconf name);
+
+    public @clock_t long times(@Out @Transient NativeTimes tms);
+    
+    int flock(int fd, int mode);
+    int unlink(CharSequence path);
+    @Variadic(fixedCount = 2)
+    int open(CharSequence path, int flags, @u_int32_t int perm);
+    int pipe(@Out int[] fds);
+    int truncate(CharSequence path, long length);
+    int ftruncate(int fd, long offset);
+    int rename(CharSequence oldName, CharSequence newName);
+    long getcwd(byte[] cwd, int len);
+    int gethostname(@Out ByteBuffer buffer, int len);
+    int fsync(int fd);
+    int fdatasync(int fd);
+
+    int socketpair(int domain, int type, int protocol, @Out int[] fds);
+    int sendmsg(int socket, @In MsgHdr message, int flags);
+    int recvmsg(int socket, @Direct MsgHdr message, int flags);
+
+    int setsockopt(int s, int level, int optname, @In ByteBuffer optval, int optlen);
+    int getsockopt(int s, int level, int optname, @Out ByteBuffer optval, @In @Out IntByReference optlen);
+
+    Variable<Long> environ();
+
+    int syscall(int number);
+    int syscall(int number, int arg1);
+    int syscall(int number, int arg1, int arg2);
+    int syscall(int number, int arg1, int arg2, int arg3);
+
+    int daemon(int nochdir, int noclose);
+
+    int getgroups(int size, int[] groups);
+
+    String nl_langinfo(int item);
+    String setlocale(int category, String locale);
+
+    String strerror(int errno);
+
+    int gettimeofday(Timeval tv, long alwaysNull);
+}
+
diff --git a/src/main/java/jnr/posix/LibCProvider.java b/src/main/java/jnr/posix/LibCProvider.java
new file mode 100644
index 0000000..a94df89
--- /dev/null
+++ b/src/main/java/jnr/posix/LibCProvider.java
@@ -0,0 +1,7 @@
+
+package jnr.posix;
+
+public interface LibCProvider {
+    public LibC getLibC();
+    public Crypt getCrypt();
+}
diff --git a/src/main/java/jnr/posix/Linux.java b/src/main/java/jnr/posix/Linux.java
new file mode 100644
index 0000000..b7e7cb2
--- /dev/null
+++ b/src/main/java/jnr/posix/Linux.java
@@ -0,0 +1,12 @@
+package jnr.posix;
+
+import jnr.constants.platform.PosixFadvise;
+
+/**
+ * Linux-specific POSIX-like functions.
+ */
+public interface Linux extends POSIX {
+    int ioprio_get(int which, int who);
+    int ioprio_set(int which, int who, int ioprio);
+    int posix_fadvise(int fd, long offset, long len, PosixFadvise advise);
+}
diff --git a/src/main/java/jnr/posix/LinuxCmsgHdr.java b/src/main/java/jnr/posix/LinuxCmsgHdr.java
new file mode 100644
index 0000000..9854e9d
--- /dev/null
+++ b/src/main/java/jnr/posix/LinuxCmsgHdr.java
@@ -0,0 +1,73 @@
+package jnr.posix;
+
+import jnr.ffi.Pointer;
+import jnr.ffi.Runtime;
+import jnr.ffi.StructLayout;
+
+/**
+ * @author Bob McWhirter
+ */
+class LinuxCmsgHdr extends BaseCmsgHdr {
+
+    public static class Layout extends StructLayout {
+
+        protected Layout(Runtime runtime) {
+            super(runtime);
+        }
+
+        // contrary to man page
+        public final size_t cmsg_len = new size_t();
+        public final Signed32 cmsg_level = new Signed32();
+        public final Signed32 cmsg_type = new Signed32();
+    }
+
+    public static final Layout layout = new Layout(Runtime.getSystemRuntime());
+
+    public LinuxCmsgHdr(NativePOSIX posix, Pointer memory) {
+        super(posix, memory);
+    }
+
+    public LinuxCmsgHdr(NativePOSIX posix, Pointer memory, int totalLen) {
+        super(posix, memory, totalLen);
+    }
+
+    public void setLevel(int level) {
+        layout.cmsg_level.set(this.memory, level);
+    }
+
+    public int getLevel() {
+        return layout.cmsg_level.get(this.memory);
+    }
+
+    public void setType(int type) {
+        layout.cmsg_type.set(this.memory, type);
+    }
+
+    public int getType() {
+        return layout.cmsg_type.get(this.memory);
+    }
+
+    public int getLen() {
+        return (int) layout.cmsg_len.get(this.memory);
+    }
+
+    void setLen(int len) {
+        layout.cmsg_len.set(this.memory, len);
+    }
+
+    public String toString(String indent) {
+        StringBuffer buf = new StringBuffer();
+
+        buf.append(indent).append("cmsg {\n");
+        buf.append(indent).append("  cmsg_len=").append(layout.cmsg_len.get(this.memory)).append("\n");
+        buf.append(indent).append("  cmsg_level=").append(layout.cmsg_level.get(this.memory)).append("\n");
+        buf.append(indent).append("  cmsg_type=").append(layout.cmsg_type.get(this.memory)).append("\n");
+        buf.append(indent).append("  cmsg_data=").append(getData()).append("\n");
+        buf.append(indent).append("}");
+        return buf.toString();
+    }
+
+    public String toString(){
+        return toString( "" );
+    }
+}
diff --git a/src/main/java/jnr/posix/LinuxFileStat32.java b/src/main/java/jnr/posix/LinuxFileStat32.java
new file mode 100644
index 0000000..333fee2
--- /dev/null
+++ b/src/main/java/jnr/posix/LinuxFileStat32.java
@@ -0,0 +1,140 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+import jnr.ffi.*;
+
+public final class LinuxFileStat32 extends BaseFileStat implements NanosecondFileStat {
+    private static final class Layout extends StructLayout {
+
+        private Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final Signed64 st_dev = new Signed64();
+        public final Signed16 __pad1 = new Signed16();
+        public final Signed32 st_ino = new Signed32();
+        public final Signed32 st_mode = new Signed32();
+        public final Signed32 st_nlink = new Signed32();
+        public final Signed32 st_uid = new Signed32();
+        public final Signed32 st_gid = new Signed32();
+        public final Signed64 st_rdev = new Signed64();
+        public final Signed16 __pad2 = new Signed16();
+        public final Signed64 st_size = new Signed64();
+        public final Signed32 st_blksize = new Signed32();
+        public final Signed32 st_blocks = new Signed32();
+        public final Signed32 __unused4 = new Signed32();
+        public final Signed32 st_atim_sec = new Signed32();     // Time of last access (time_t)
+        public final Signed32 st_atim_nsec = new Signed32(); // Time of last access (nanoseconds)
+        public final Signed32 st_mtim_sec = new Signed32();     // Last data modification time (time_t)
+        public final Signed32 st_mtim_nsec = new Signed32(); // Last data modification time (nanoseconds)
+        public final Signed32 st_ctim_sec = new Signed32();     // Time of last status change (time_t)
+        public final Signed32 st_ctim_nsec = new Signed32(); // Time of last status change (nanoseconds)
+        public final Signed64 __unused5 = new Signed64();
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public LinuxFileStat32() {
+        this(null);
+    }
+
+    public LinuxFileStat32(BaseNativePOSIX posix) {
+        super(posix, layout);
+    }
+    
+    public long atime() {
+        return layout.st_atim_sec.get(memory);
+    }
+
+    @Override
+    public long aTimeNanoSecs() {
+        return layout.st_atim_nsec.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctim_sec.get(memory);
+    }
+
+    @Override
+    public long cTimeNanoSecs() {
+        return layout.st_ctim_nsec.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return layout.st_mode.get(memory) & 0xffff;
+    }
+
+    public long mtime() {
+        return layout.st_mtim_sec.get(memory);
+    }
+
+    @Override
+    public long mTimeNanoSecs() {
+        return layout.st_mtim_nsec.get(memory);
+    }
+
+    public int nlink() {
+        return layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout.st_size.get(memory);
+    }
+
+    public int uid() {
+        return layout.st_uid.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/LinuxFileStat64.java b/src/main/java/jnr/posix/LinuxFileStat64.java
new file mode 100644
index 0000000..1a51523
--- /dev/null
+++ b/src/main/java/jnr/posix/LinuxFileStat64.java
@@ -0,0 +1,102 @@
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+
+public final class LinuxFileStat64 extends BaseFileStat implements NanosecondFileStat {
+    public static final class Layout extends StructLayout {
+
+        public Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final dev_t st_dev = new dev_t();
+        public final ino_t st_ino = new ino_t();
+        public final nlink_t st_nlink = new nlink_t();
+        public final mode_t st_mode = new mode_t();
+        public final uid_t st_uid = new uid_t();
+        public final gid_t st_gid = new gid_t();
+        public final dev_t st_rdev = new dev_t();
+        public final off_t st_size = new off_t();
+        public final blksize_t st_blksize = new blksize_t();
+        public final blkcnt_t st_blocks = new blkcnt_t();
+        public final time_t st_atime = new time_t();     // Time of last access (time_t)
+        public final SignedLong st_atimensec = new SignedLong(); // Time of last access (nanoseconds)
+        public final time_t st_mtime = new time_t();     // Last data modification time (time_t)
+        public final SignedLong st_mtimensec = new SignedLong(); // Last data modification time (nanoseconds)
+        public final time_t st_ctime = new time_t();     // Time of last status change (time_t)
+        public final SignedLong st_ctimensec = new SignedLong(); // Time of last status change (nanoseconds)
+        public final Signed64 __unused4 = new Signed64();
+        public final Signed64 __unused5 = new Signed64();
+        public final Signed64 __unused6 = new Signed64();
+    }
+
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public LinuxFileStat64(LinuxPOSIX posix) {
+        super(posix, layout);
+    }
+
+    public long atime() {
+        return layout.st_atime.get(memory);
+    }
+
+    public long aTimeNanoSecs() {
+        return layout.st_atimensec.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctime.get(memory);
+    }
+
+    public long cTimeNanoSecs() {
+        return layout.st_ctimensec.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return (int) layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return (int) layout.st_mode.get(memory);
+    }
+
+    public long mtime() {
+        return layout.st_mtime.get(memory);
+    }
+
+    public long mTimeNanoSecs() {
+        return layout.st_mtimensec.get(memory);
+    }
+
+    public int nlink() {
+        return (int) layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout. st_size.get(memory);
+    }
+
+    public int uid() {
+        return (int) layout.st_uid.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/LinuxFileStatAARCH64.java b/src/main/java/jnr/posix/LinuxFileStatAARCH64.java
new file mode 100644
index 0000000..d5df659
--- /dev/null
+++ b/src/main/java/jnr/posix/LinuxFileStatAARCH64.java
@@ -0,0 +1,104 @@
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+import jnr.posix.util.Platform;
+
+public final class LinuxFileStatAARCH64 extends BaseFileStat implements NanosecondFileStat {
+    public static final class Layout extends StructLayout {
+
+        public Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final dev_t st_dev = new dev_t();
+        public final ino_t st_ino = new ino_t();
+        public final mode_t st_mode = new mode_t();
+        public final nlink_t st_nlink = new nlink_t();
+        public final uid_t st_uid = new uid_t();
+        public final gid_t st_gid = new gid_t();
+        public final dev_t st_rdev = new dev_t();
+        public final dev_t __pad1 = new dev_t();
+        public final off_t st_size = new off_t();
+        public final blksize_t st_blksize = new blksize_t();
+        public final Signed32 __pad2 = new Signed32();
+        public final blkcnt_t st_blocks = new blkcnt_t();
+        public final time_t st_atime = new time_t();             // Time of last access
+        public final SignedLong st_atimensec = new SignedLong(); // Time of last access (nanoseconds)
+        public final time_t st_mtime = new time_t();             // Last data modification time
+        public final SignedLong st_mtimensec = new SignedLong(); // Last data modification time (nanoseconds)
+        public final time_t st_ctime = new time_t();             // Time of last status change
+        public final SignedLong st_ctimensec = new SignedLong(); // Time of last status change (nanoseconds)
+        public final Signed32 __unused4 = new Signed32();
+        public final Signed32 __unused5 = new Signed32();
+    }
+
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public LinuxFileStatAARCH64(LinuxPOSIX posix) {
+        super(posix, layout);
+    }
+
+    public long atime() {
+        return layout.st_atime.get(memory);
+    }
+
+    public long aTimeNanoSecs() {
+        return layout.st_atimensec.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctime.get(memory);
+    }
+
+    public long cTimeNanoSecs() {
+        return layout.st_ctimensec.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return (int) layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return (int) layout.st_mode.get(memory);
+    }
+
+    public long mtime() {
+        return layout.st_mtime.get(memory);
+    }
+
+    public long mTimeNanoSecs() {
+        return layout.st_mtimensec.get(memory);
+    }
+
+    public int nlink() {
+        return (int) layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout. st_size.get(memory);
+    }
+
+    public int uid() {
+        return (int) layout.st_uid.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/LinuxFileStatLOONGARCH64.java b/src/main/java/jnr/posix/LinuxFileStatLOONGARCH64.java
new file mode 100644
index 0000000..54b1871
--- /dev/null
+++ b/src/main/java/jnr/posix/LinuxFileStatLOONGARCH64.java
@@ -0,0 +1,104 @@
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+import jnr.posix.util.Platform;
+
+public final class LinuxFileStatLOONGARCH64 extends BaseFileStat implements NanosecondFileStat {
+    public static final class Layout extends StructLayout {
+
+        public Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final dev_t st_dev = new dev_t();
+        public final ino_t st_ino = new ino_t();
+        public final mode_t st_mode = new mode_t();
+        public final nlink_t st_nlink = new nlink_t();
+        public final uid_t st_uid = new uid_t();
+        public final gid_t st_gid = new gid_t();
+        public final dev_t st_rdev = new dev_t();
+        public final dev_t __pad1 = new dev_t();
+        public final off_t st_size = new off_t();
+        public final blksize_t st_blksize = new blksize_t();
+        public final Signed32 __pad2 = new Signed32();
+        public final blkcnt_t st_blocks = new blkcnt_t();
+        public final time_t st_atime = new time_t();             // Time of last access
+        public final SignedLong st_atimensec = new SignedLong(); // Time of last access (nanoseconds)
+        public final time_t st_mtime = new time_t();             // Last data modification time
+        public final SignedLong st_mtimensec = new SignedLong(); // Last data modification time (nanoseconds)
+        public final time_t st_ctime = new time_t();             // Time of last status change
+        public final SignedLong st_ctimensec = new SignedLong(); // Time of last status change (nanoseconds)
+        public final Signed32 __unused4 = new Signed32();
+        public final Signed32 __unused5 = new Signed32();
+    }
+
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public LinuxFileStatLOONGARCH64(LinuxPOSIX posix) {
+        super(posix, layout);
+    }
+
+    public long atime() {
+        return layout.st_atime.get(memory);
+    }
+
+    public long aTimeNanoSecs() {
+        return layout.st_atimensec.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctime.get(memory);
+    }
+
+    public long cTimeNanoSecs() {
+        return layout.st_ctimensec.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return (int) layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return (int) layout.st_mode.get(memory);
+    }
+
+    public long mtime() {
+        return layout.st_mtime.get(memory);
+    }
+
+    public long mTimeNanoSecs() {
+        return layout.st_mtimensec.get(memory);
+    }
+
+    public int nlink() {
+        return (int) layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout. st_size.get(memory);
+    }
+
+    public int uid() {
+        return (int) layout.st_uid.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/LinuxFileStatMIPS64.java b/src/main/java/jnr/posix/LinuxFileStatMIPS64.java
new file mode 100644
index 0000000..ac16548
--- /dev/null
+++ b/src/main/java/jnr/posix/LinuxFileStatMIPS64.java
@@ -0,0 +1,110 @@
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+
+public final class LinuxFileStatMIPS64 extends BaseFileStat implements NanosecondFileStat {
+    public static final class Layout extends StructLayout {
+
+        public Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final Unsigned64 st_dev = new Unsigned64();
+        public final Unsigned32 __pad01 = new Unsigned32();
+        public final Unsigned32 __pad02 = new Unsigned32();
+        public final Unsigned32 __pad03 = new Unsigned32();
+
+        public final Unsigned64 st_ino = new Unsigned64();
+        public final Unsigned64 st_mode = new Unsigned64();
+        public final Unsigned32 st_nlink = new Unsigned32();
+        public final Unsigned32 st_uid = new Unsigned32();
+        public final Unsigned32 st_gid = new Unsigned32();
+        public final Unsigned64 st_rdev = new Unsigned64();
+	public final Unsigned32 __pad11 = new Unsigned32();
+        public final Unsigned32 __pad12 = new Unsigned32();
+        public final Unsigned32 __pad13 = new Unsigned32();
+
+        public final Signed64	st_size = new Signed64();
+
+        public final Unsigned64	st_atime = new Unsigned64();     // Time of last access (time_t)
+        public final Unsigned64	st_atimensec = new Unsigned64(); // Time of last access (nanoseconds)
+        public final Unsigned64	st_mtime = new Unsigned64();     // Last data modification time (time_t)
+        public final Unsigned64	st_mtimensec = new Unsigned64(); // Last data modification time (nanoseconds)
+        public final Unsigned64	st_ctime = new Unsigned64();     // Time of last status change (time_t)
+        public final Unsigned64	st_ctimensec = new Unsigned64(); // Time of last status change (nanoseconds)
+
+        public final Unsigned64	st_blksize = new Unsigned64();
+        public final Unsigned32	__pad20 = new Unsigned32();
+        public final Unsigned64	st_blocks = new Unsigned64();
+    }
+
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public LinuxFileStatMIPS64(LinuxPOSIX posix) {
+        super(posix, layout);
+    }
+
+    public long atime() {
+        return layout.st_atime.get(memory);
+    }
+
+    public long aTimeNanoSecs() {
+        return layout.st_atimensec.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctime.get(memory);
+    }
+
+    public long cTimeNanoSecs() {
+        return layout.st_ctimensec.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return (int) layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return (int) layout.st_mode.get(memory);
+    }
+
+    public long mtime() {
+        return layout.st_mtime.get(memory);
+    }
+
+    public long mTimeNanoSecs() {
+        return layout.st_mtimensec.get(memory);
+    }
+
+    public int nlink() {
+        return (int) layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout. st_size.get(memory);
+    }
+
+    public int uid() {
+        return (int) layout.st_uid.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/LinuxFileStatRISCV64.java b/src/main/java/jnr/posix/LinuxFileStatRISCV64.java
new file mode 100644
index 0000000..94093ea
--- /dev/null
+++ b/src/main/java/jnr/posix/LinuxFileStatRISCV64.java
@@ -0,0 +1,104 @@
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+import jnr.posix.util.Platform;
+
+public final class LinuxFileStatRISCV64 extends BaseFileStat implements NanosecondFileStat {
+    public static final class Layout extends StructLayout {
+
+        public Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final dev_t st_dev = new dev_t();
+        public final ino_t st_ino = new ino_t();
+        public final mode_t st_mode = new mode_t();
+        public final nlink_t st_nlink = new nlink_t();
+        public final uid_t st_uid = new uid_t();
+        public final gid_t st_gid = new gid_t();
+        public final dev_t st_rdev = new dev_t();
+        public final dev_t __pad1 = new dev_t();
+        public final off_t st_size = new off_t();
+        public final blksize_t st_blksize = new blksize_t();
+        public final Signed32 __pad2 = new Signed32();
+        public final blkcnt_t st_blocks = new blkcnt_t();
+        public final time_t st_atime = new time_t();             // Time of last access
+        public final SignedLong st_atimensec = new SignedLong(); // Time of last access (nanoseconds)
+        public final time_t st_mtime = new time_t();             // Last data modification time
+        public final SignedLong st_mtimensec = new SignedLong(); // Last data modification time (nanoseconds)
+        public final time_t st_ctime = new time_t();             // Time of last status change
+        public final SignedLong st_ctimensec = new SignedLong(); // Time of last status change (nanoseconds)
+        public final Signed32 __unused4 = new Signed32();
+        public final Signed32 __unused5 = new Signed32();
+    }
+
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public LinuxFileStatRISCV64(LinuxPOSIX posix) {
+        super(posix, layout);
+    }
+
+    public long atime() {
+        return layout.st_atime.get(memory);
+    }
+
+    public long aTimeNanoSecs() {
+        return layout.st_atimensec.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctime.get(memory);
+    }
+
+    public long cTimeNanoSecs() {
+        return layout.st_ctimensec.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return (int) layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return (int) layout.st_mode.get(memory);
+    }
+
+    public long mtime() {
+        return layout.st_mtime.get(memory);
+    }
+
+    public long mTimeNanoSecs() {
+        return layout.st_mtimensec.get(memory);
+    }
+
+    public int nlink() {
+        return (int) layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout. st_size.get(memory);
+    }
+
+    public int uid() {
+        return (int) layout.st_uid.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/LinuxFileStatSPARCV9.java b/src/main/java/jnr/posix/LinuxFileStatSPARCV9.java
new file mode 100644
index 0000000..bc620c7
--- /dev/null
+++ b/src/main/java/jnr/posix/LinuxFileStatSPARCV9.java
@@ -0,0 +1,103 @@
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+
+public class LinuxFileStatSPARCV9 extends BaseFileStat implements NanosecondFileStat {
+    public static final class Layout extends StructLayout {
+
+        public Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final dev_t st_dev = new dev_t();
+        public final Unsigned16 __pad1  = new Unsigned16();
+        public final ino_t st_ino = new ino_t();
+        public final mode_t st_mode = new mode_t();
+        public final nlink_t st_nlink = new nlink_t();
+        public final uid_t st_uid = new uid_t();
+        public final gid_t st_gid = new gid_t();
+        public final dev_t st_rdev = new dev_t();
+        public final Unsigned16 __pad2 = new Unsigned16();
+        public final off_t st_size = new off_t();
+        public final blksize_t st_blksize = new blksize_t();
+        public final blkcnt_t st_blocks = new blkcnt_t();
+        public final time_t st_atime = new time_t();     // Time of last access (time_t)
+        public final SignedLong st_atimensec = new SignedLong(); // Time of last access (nanoseconds)
+        public final time_t st_mtime = new time_t();     // Last data modification time (time_t)
+        public final SignedLong st_mtimensec = new SignedLong(); // Last data modification time (nanoseconds)
+        public final time_t st_ctime = new time_t();     // Time of last status change (time_t)
+        public final SignedLong st_ctimensec = new SignedLong(); // Time of last status change (nanoseconds)
+        public final Unsigned64 __unused4 = new Unsigned64();
+        public final Unsigned64 __unused5 = new Unsigned64();
+    }
+
+    public static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public LinuxFileStatSPARCV9(LinuxPOSIX posix) {
+        super(posix, layout);
+    }
+
+    public long atime() {
+        return layout.st_atime.get(memory);
+    }
+
+    public long aTimeNanoSecs() {
+        return layout.st_atimensec.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctime.get(memory);
+    }
+
+    public long cTimeNanoSecs() {
+        return layout.st_ctimensec.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return (int) layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return (int) layout.st_mode.get(memory);
+    }
+
+    public long mtime() {
+        return layout.st_mtime.get(memory);
+    }
+
+    public long mTimeNanoSecs() {
+        return layout.st_mtimensec.get(memory);
+    }
+
+    public int nlink() {
+        return (int) layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout. st_size.get(memory);
+    }
+
+    public int uid() {
+        return (int) layout.st_uid.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/LinuxIoPrio.java b/src/main/java/jnr/posix/LinuxIoPrio.java
new file mode 100644
index 0000000..3b09993
--- /dev/null
+++ b/src/main/java/jnr/posix/LinuxIoPrio.java
@@ -0,0 +1,24 @@
+package jnr.posix;
+
+public abstract class LinuxIoPrio {
+    public static int IOPRIO_WHO_PROCESS = 1;
+    public static int IOPRIO_WHO_PGRP = 2;
+    public static int IOPRIO_WHO_USER = 3;
+
+    public static int IOPRIO_CLASS_NONE = 0;
+    public static int IOPRIO_CLASS_RT = 1;
+    public static int IOPRIO_CLASS_BE = 2;
+    public static int IOPRIO_CLASS_IDLE = 3;
+
+    public static int IOPRIO_PRIO_VALUE(int _class, int data) {
+        return (_class << 13) | data;
+    }
+
+    public static int IOPRIO_PRIO_CLASS(int mask) {
+        return mask >> 13;
+    }
+
+    public static int IOPRIO_PRIO_DATA(int mask) {
+        return mask & 0x0f;
+    }
+}
diff --git a/src/main/java/jnr/posix/LinuxLibC.java b/src/main/java/jnr/posix/LinuxLibC.java
new file mode 100644
index 0000000..3275843
--- /dev/null
+++ b/src/main/java/jnr/posix/LinuxLibC.java
@@ -0,0 +1,22 @@
+package jnr.posix;
+
+import jnr.ffi.annotations.In;
+import jnr.ffi.annotations.NulTerminate;
+import jnr.ffi.annotations.Out;
+import jnr.ffi.annotations.Transient;
+import jnr.ffi.types.off_t;
+import java.nio.ByteBuffer;
+
+public interface LinuxLibC extends UnixLibC {
+    public int __fxstat(int version, int fd, @Out @Transient FileStat stat);
+    public int __lxstat(int version, CharSequence path, @Out @Transient FileStat stat);
+    public int __lxstat(int version, @NulTerminate @In ByteBuffer path, @Out @Transient FileStat stat);
+    public int __xstat(int version, CharSequence path, @Out @Transient FileStat stat);
+    public int __xstat(int version, @NulTerminate @In ByteBuffer path, @Out @Transient FileStat stat);
+    public int __fxstat64(int version, int fd, @Out @Transient FileStat stat);
+    public int __lxstat64(int version, CharSequence path, @Out @Transient FileStat stat);
+    public int __lxstat64(int version, @NulTerminate @In ByteBuffer path, @Out @Transient FileStat stat);
+    public int __xstat64(int version, CharSequence path, @Out @Transient FileStat stat);
+    public int __xstat64(int version, @NulTerminate @In ByteBuffer path, @Out @Transient FileStat stat);
+    public int posix_fadvise(int fd, @off_t long offset, @off_t long len, int advice);
+}
diff --git a/src/main/java/jnr/posix/LinuxMsgHdr.java b/src/main/java/jnr/posix/LinuxMsgHdr.java
new file mode 100644
index 0000000..039479c
--- /dev/null
+++ b/src/main/java/jnr/posix/LinuxMsgHdr.java
@@ -0,0 +1,173 @@
+package jnr.posix;
+
+import java.util.ArrayList;
+import java.util.List;
+import jnr.ffi.Pointer;
+import jnr.ffi.Runtime;
+import jnr.ffi.StructLayout;
+
+/**
+ * @author Bob McWhirter
+ */
+class LinuxMsgHdr extends BaseMsgHdr {
+
+    public static class Layout extends StructLayout {
+        protected Layout(Runtime runtime) {
+            super(runtime);
+        }
+
+        public final Pointer msg_name = new Pointer();
+        public final socklen_t msg_namelen = new socklen_t();
+        public final Pointer msg_iov = new Pointer();
+        public final size_t msg_iovlen = new size_t();
+        public final Pointer msg_control = new Pointer();
+        public final size_t msg_controllen = new size_t();
+        public final Signed32 msg_flags = new Signed32();
+    }
+
+    private static final Layout layout = new Layout(Runtime.getSystemRuntime());
+
+    protected LinuxMsgHdr(NativePOSIX posix) {
+        super(posix, layout);
+        setName(null);
+    }
+
+    CmsgHdr allocateCmsgHdrInternal(NativePOSIX posix, Pointer pointer, int len) {
+        if (len > 0) {
+            return new LinuxCmsgHdr(posix, pointer, len);
+        } else {
+            return new LinuxCmsgHdr(posix, pointer);
+        }
+    }
+
+    @Override
+    void setControlPointer(Pointer control) {
+        layout.msg_control.set(this.memory, control);
+    }
+
+    @Override
+    void setControlLen(int len) {
+        layout.msg_controllen.set(this.memory, len);
+    }
+
+    public String toString() {
+        StringBuffer buf = new StringBuffer();
+        buf.append("msghdr {\n");
+        buf.append("  msg_name=").append(getName()).append(",\n");
+        buf.append("  msg_namelen=").append(getNameLen()).append(",\n");
+
+        buf.append("  msg_iov=[\n");
+        Pointer iovp = layout.msg_iov.get(this.memory);
+
+        int numIov = getIovLen();
+        for (int i = 0; i < numIov; ++i) {
+            Pointer eachp = iovp.slice(i * BaseIovec.layout.size());
+            buf.append(new BaseIovec(posix, eachp).toString("    "));
+            if (i < (numIov - 1)) {
+                buf.append(",\n");
+            } else {
+                buf.append("\n");
+            }
+        }
+        buf.append("  ],\n");
+
+        buf.append("  msg_control=[\n");
+
+        CmsgHdr[] controls = getControls();
+        for (int i = 0; i < controls.length; ++i) {
+            buf.append(((LinuxCmsgHdr) controls[i]).toString("    "));
+            if (i < controls.length - 1) {
+                buf.append(",\n");
+            } else {
+                buf.append("\n");
+            }
+        }
+        buf.append("  ],\n");
+        buf.append("  msg_controllen=").append(layout.msg_controllen.get(this.memory)).append("\n");
+
+        buf.append("  msg_iovlen=").append(getIovLen()).append(",\n");
+        buf.append("  msg_flags=").append(getFlags()).append(",\n");
+        buf.append("}");
+        return buf.toString();
+    }
+
+    @Override
+    void setNamePointer(Pointer name) {
+        layout.msg_name.set( this.memory, name );
+    }
+
+    @Override
+    Pointer getNamePointer() {
+        return layout.msg_name.get( this.memory );
+    }
+
+
+    @Override
+    void setNameLen(int len) {
+        layout.msg_namelen.set(this.memory, len);
+    }
+
+    @Override
+    int getNameLen() {
+        return (int) layout.msg_namelen.get(this.memory);
+    }
+
+    @Override
+    void setIovPointer(Pointer iov) {
+        layout.msg_iov.set(this.memory, iov);
+    }
+
+    @Override
+    Pointer getIovPointer() {
+        return layout.msg_iov.get( this.memory );
+    }
+
+    @Override
+    void setIovLen(int len) {
+        layout.msg_iovlen.set(this.memory, len);
+    }
+
+    @Override
+    int getIovLen() {
+        return (int) layout.msg_iovlen.get(this.memory);
+    }
+
+    @Override
+    Pointer getControlPointer() {
+        return layout.msg_control.get(this.memory);
+    }
+
+    public int getControlLen() {
+        return (int) layout.msg_controllen.get(this.memory);
+    }
+
+    public void setFlags(int flags) {
+        layout.msg_flags.set(this.memory, flags);
+    }
+
+    public int getFlags() {
+        return layout.msg_flags.get(this.memory);
+    }
+
+    @Override
+    public CmsgHdr[] getControls() {
+        int len = getControlLen();
+        if (len == 0) {
+            return new CmsgHdr[0];
+        }
+
+        List<CmsgHdr> control = new ArrayList<CmsgHdr>();
+
+        int offset = 0;
+
+        Pointer controlPtr = getControlPointer();
+
+        while (offset < len) {
+            CmsgHdr each = allocateCmsgHdrInternal(posix, controlPtr.slice(offset), -1);
+            offset += LinuxSocketMacros.INSTANCE.CMSG_ALIGN( each.getLen() );
+            control.add(each);
+        }
+
+        return control.toArray(new CmsgHdr[control.size()]);
+    }
+}
diff --git a/src/main/java/jnr/posix/LinuxPOSIX.java b/src/main/java/jnr/posix/LinuxPOSIX.java
new file mode 100644
index 0000000..4a65400
--- /dev/null
+++ b/src/main/java/jnr/posix/LinuxPOSIX.java
@@ -0,0 +1,357 @@
+package jnr.posix;
+
+import jnr.constants.platform.Errno;
+import jnr.constants.platform.PosixFadvise;
+import jnr.constants.platform.Sysconf;
+import jnr.ffi.Memory;
+import jnr.ffi.Pointer;
+import jnr.ffi.mapper.FromNativeContext;
+import jnr.posix.util.Platform;
+
+import java.io.FileDescriptor;
+import java.nio.ByteBuffer;
+import jnr.constants.platform.Confstr;
+import jnr.constants.platform.Pathconf;
+
+final class LinuxPOSIX extends BaseNativePOSIX implements Linux {
+    private final boolean use_stat64;
+    private final int statVersion;
+
+    LinuxPOSIX(LibCProvider libcProvider, POSIXHandler handler) {
+        super(libcProvider, handler);
+
+        statVersion = getStatVersion();
+        use_stat64 = statVersion >= 0;
+    }
+
+    private int getStatVersion() {
+        if (Platform.IS_32_BIT || "sparcv9".equals(Platform.ARCH) || Platform.ARCH.contains("mips64")) {
+            return 3;
+        } else {
+            FileStat stat = allocateStat();
+            try {
+                if (((LinuxLibC) libc()).__xstat64(0, "/dev/null", stat) < 0) {
+                    return 1;
+                }
+                return 0;
+            } catch (UnsatisfiedLinkError ex) {
+                return -1;
+            }
+        }
+    }
+
+    @Override
+    public FileStat allocateStat() {
+        if (Platform.IS_32_BIT) {
+            return new LinuxFileStat32(this);
+        } else {
+            if ("aarch64".equals(Platform.ARCH)) {
+                return new LinuxFileStatAARCH64(this);
+            } else if ("riscv64".equals(Platform.ARCH)) {
+                return new LinuxFileStatRISCV64(this);
+            } else if ("sparcv9".equals(Platform.ARCH)) {
+		return new LinuxFileStatSPARCV9(this);
+	    } else if ("loongarch64".equals(Platform.ARCH)) {
+		return new LinuxFileStatLOONGARCH64(this);
+	    } else {
+		if (Platform.ARCH.contains("mips64")) {
+		    return new LinuxFileStatMIPS64(this);
+		}
+                return new LinuxFileStat64(this);
+	    }
+	}
+    }
+
+    public MsgHdr allocateMsgHdr() {
+        return new LinuxMsgHdr(this);
+    }
+
+    @Override
+    public Pointer allocatePosixSpawnFileActions() {
+        return Memory.allocateDirect(getRuntime(), 80);
+    }
+
+    @Override
+    public Pointer allocatePosixSpawnattr() {
+        return Memory.allocateDirect(getRuntime(), 336);
+    }
+
+    public SocketMacros socketMacros() {
+        return LinuxSocketMacros.INSTANCE;
+    }
+
+    private int old_fstat(int fd, FileStat stat) {
+        try {
+            return super.fstat(fd, stat);
+        } catch (UnsatisfiedLinkError ex2) {
+            handler.unimplementedError("fstat");
+            return -1;
+        }
+    }
+
+    @Override
+    public int fstat(int fd, FileStat stat) {
+        if (use_stat64) {
+            return ((LinuxLibC) libc()).__fxstat64(statVersion, fd, stat);
+        } else {
+            return old_fstat(fd, stat);
+        }
+    }
+
+    @Override
+    public FileStat fstat(int fd) {
+        FileStat stat = allocateStat();
+        int ret = fstat(fd, stat);
+        if (ret < 0) handler.error(Errno.valueOf(errno()), "fstat", Integer.toString(fd));
+        return stat;
+    }
+
+    @Override
+    public int fstat(FileDescriptor fileDescriptor, FileStat stat) {
+        return fstat(helper.getfd(fileDescriptor), stat);
+    }
+
+    @Override
+    public FileStat fstat(FileDescriptor fileDescriptor) {
+        FileStat stat = allocateStat();
+        int fd = helper.getfd(fileDescriptor);
+        int ret = fstat(fd, stat);
+        if (ret < 0) handler.error(Errno.valueOf(errno()), "fstat", Integer.toString(fd));
+        return stat;
+    }
+
+    private final int old_lstat(String path, FileStat stat) {
+        try {
+            return super.lstat(path, stat);
+        } catch (UnsatisfiedLinkError ex) {
+            handler.unimplementedError("lstat");
+            return -1;
+        }
+    }
+
+    @Override
+    public int lstat(String path, FileStat stat) {
+        if (use_stat64) {
+            return ((LinuxLibC) libc()).__lxstat64(statVersion, path, stat);
+        } else {
+            return old_lstat(path, stat);
+        }
+    }
+
+    @Override
+    public FileStat lstat(String path) {
+        FileStat stat = allocateStat();
+        int ret = lstat(path, stat);
+        if (ret < 0) handler.error(Errno.valueOf(errno()), "lstat", path);
+        return stat;
+    }
+
+    private final int old_stat(String path, FileStat stat) {
+        try {
+            return super.stat(path, stat);
+        } catch (UnsatisfiedLinkError ex) {
+            handler.unimplementedError("stat");
+            return -1;
+        }
+    }
+
+    @Override
+    public int stat(String path, FileStat stat) {
+
+        if (use_stat64) {
+            return ((LinuxLibC) libc()).__xstat64(statVersion, path, stat);
+        } else {
+            return old_stat(path, stat);
+        }
+    }
+
+    @Override
+    public FileStat stat(String path) {
+        FileStat stat = allocateStat();
+        int ret = stat(path, stat);
+        if (ret < 0) handler.error(Errno.valueOf(errno()), "stat", path);
+        return stat;
+    }
+
+    public long sysconf(Sysconf name) {
+        return libc().sysconf(name);
+    }
+
+    public int confstr(Confstr name, ByteBuffer buf, int len) {
+        return libc().confstr(name, buf, len);
+    }
+
+    public int fpathconf(int fd, Pathconf name) {
+        return libc().fpathconf(fd, name);
+    }
+
+    public Times times() {
+        return NativeTimes.times(this);
+    }
+
+    public static final PointerConverter PASSWD = new PointerConverter() {
+        public Object fromNative(Object arg, FromNativeContext ctx) {
+            return arg != null ? new LinuxPasswd((Pointer) arg) : null;
+        }
+    };
+
+    static final public class Syscall {
+        static final ABI _ABI_X86_32 = new ABI_X86_32();
+        static final ABI _ABI_X86_64 = new ABI_X86_64();
+        static final ABI _ABI_AARCH64 = new ABI_AARCH64();
+        static final ABI _ABI_SPARCV9 = new ABI_SPARCV9();
+        static final ABI _ABI_PPC64 = new ABI_PPC64();
+        static final ABI _ABI_MIPS64 = new ABI_MIPS64();
+        static final ABI _ABI_LOONGARCH64 = new ABI_LOONGARCH64();
+	static final ABI _ABI_RISCV64 = new ABI_RISCV64();
+
+        public static ABI abi() {
+            if ("x86_64".equals(Platform.ARCH)) {
+                if (Platform.IS_64_BIT) {
+                    return _ABI_X86_64;
+                }
+            } else if ("i386".equals(Platform.ARCH)) {
+                return _ABI_X86_32;
+            } else if ("aarch64".equals(Platform.ARCH)) {
+                return _ABI_AARCH64;
+            } else if ("sparcv9".equals(Platform.ARCH)) {
+                return _ABI_SPARCV9;
+            } else if (Platform.ARCH.contains("ppc64")) {
+                return _ABI_PPC64;
+            } else if (Platform.ARCH.contains("mips64")) {
+	    	return _ABI_MIPS64;
+	    } else if (Platform.ARCH.contains("loongarch64")) {
+		return _ABI_LOONGARCH64;
+	    } else if (Platform.ARCH.contains("riscv64")) {
+                return _ABI_RISCV64;
+	    }
+            return null;
+        }
+
+        interface ABI {
+            public int __NR_ioprio_set();
+            public int __NR_ioprio_get();
+        }
+
+        /** @see /usr/include/asm/unistd_32.h */
+        final static class ABI_X86_32 implements ABI {
+            @Override
+            public int __NR_ioprio_set() {
+                return 289;
+            }
+            @Override
+            public int __NR_ioprio_get() {
+                return 290;
+            }
+        }
+
+        /** @see /usr/include/asm/unistd_64.h */
+        final static class ABI_X86_64 implements ABI {
+            @Override
+            public int __NR_ioprio_set() {
+                return 251;
+            }
+            @Override
+            public int __NR_ioprio_get() {
+                return 252;
+            }
+        }
+
+        /** @see /usr/include/asm-generic/unistd.h */
+        final static class ABI_AARCH64 implements ABI {
+            @Override
+            public int __NR_ioprio_set() {
+                return 30;
+            }
+            @Override
+            public int __NR_ioprio_get() {
+                return 31 ;
+            }
+        }
+
+        /** @see /usr/include/asm/unistd.h */
+        final static class ABI_SPARCV9 implements ABI {
+            @Override
+            public int __NR_ioprio_set() {
+                return 196;
+            }
+            @Override
+            public int __NR_ioprio_get() {
+                return 218;
+            }
+        }
+
+        /** @see /usr/include/asm-generic/unistd.h */
+        final static class ABI_PPC64 implements ABI {
+            @Override
+            public int __NR_ioprio_set() {
+                return 273;
+            }
+            @Override
+            public int __NR_ioprio_get() {
+                return 274 ;
+            }
+        }
+
+        /** @see /usr/include/asm/unistd.h */
+        final static class ABI_MIPS64 implements ABI {
+            @Override
+            public int __NR_ioprio_set() {
+                return 5273;
+            }
+            @Override
+            public int __NR_ioprio_get() {
+                return 5274;
+            }
+        }
+
+        /** @see /usr/include/asm-generic/unistd.h */
+        final static class ABI_LOONGARCH64 implements ABI {
+            @Override
+            public int __NR_ioprio_set() {
+                return 30;
+            }
+            @Override
+            public int __NR_ioprio_get() {
+                return 31;
+            }
+        }
+	    
+	/** @see /usr/include/asm-generic/unistd.h */
+        final static class ABI_RISCV64 implements ABI {
+            @Override
+            public int __NR_ioprio_set() {
+                return 30;
+            }
+            @Override
+            public int __NR_ioprio_get() {
+                return 31 ;
+            }
+        }
+    }
+
+
+    public int ioprio_get(int which, int who) {
+        Syscall.ABI abi = Syscall.abi();
+        if (abi == null) {
+            handler.unimplementedError("ioprio_get");
+            return -1;
+        }
+
+        return libc().syscall(abi.__NR_ioprio_get(), which, who);
+    }
+
+    public int ioprio_set(int which, int who, int ioprio) {
+        Syscall.ABI abi = Syscall.abi();
+        if (abi == null) {
+            handler.unimplementedError("ioprio_set");
+            return -1;
+        }
+
+        return libc().syscall(abi.__NR_ioprio_set(), which, who, ioprio);
+    }
+
+    public int posix_fadvise(int fd, long offset, long len, PosixFadvise advise) {
+        return ((LinuxLibC) libc()).posix_fadvise(fd, offset, len, advise.intValue());
+    }
+}
diff --git a/src/main/java/jnr/posix/LinuxPasswd.java b/src/main/java/jnr/posix/LinuxPasswd.java
new file mode 100644
index 0000000..56669ba
--- /dev/null
+++ b/src/main/java/jnr/posix/LinuxPasswd.java
@@ -0,0 +1,57 @@
+
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+
+public final class LinuxPasswd extends NativePasswd implements Passwd {
+    private static final class Layout extends StructLayout {
+
+        private Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final UTF8StringRef pw_name = new UTF8StringRef();   // user name
+        public final UTF8StringRef pw_passwd = new UTF8StringRef(); // password (encrypted)
+        public final Signed32 pw_uid = new Signed32();       // user id
+        public final Signed32 pw_gid = new Signed32();       // user id
+        public final UTF8StringRef pw_gecos = new UTF8StringRef();  // login info
+        public final UTF8StringRef pw_dir = new UTF8StringRef();    // home directory
+        public final UTF8StringRef pw_shell = new UTF8StringRef();  // default shell
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    LinuxPasswd(jnr.ffi.Pointer memory) {
+        super(memory);
+    }
+    
+    public java.lang.String getAccessClass() {
+        return "";
+    }
+    public java.lang.String getGECOS() {
+        return layout.pw_gecos.get(memory);
+    }
+    public long getGID() {
+        return layout.pw_gid.get(memory);
+    }
+    public java.lang.String getHome() {
+        return layout.pw_dir.get(memory);
+    }
+    public java.lang.String getLoginName() {
+        return layout.pw_name.get(memory);
+    }
+    public java.lang.String getPassword() {
+        return layout.pw_passwd.get(memory);
+    }
+    public java.lang.String getShell() {
+        return layout.pw_shell.get(memory);
+    }
+    public long getUID() {
+        return layout.pw_uid.get(memory);
+    }
+    public int getPasswdChangeTime() {
+        return 0;
+    }
+    public int getExpire() {
+        return Integer.MAX_VALUE;
+    }
+}
diff --git a/src/main/java/jnr/posix/LinuxSocketMacros.java b/src/main/java/jnr/posix/LinuxSocketMacros.java
new file mode 100644
index 0000000..d124f1c
--- /dev/null
+++ b/src/main/java/jnr/posix/LinuxSocketMacros.java
@@ -0,0 +1,29 @@
+package jnr.posix;
+
+import jnr.ffi.*;
+import jnr.ffi.Runtime;
+
+/**
+ * @author Bob McWhirter
+ */
+public class LinuxSocketMacros implements SocketMacros {
+
+    public static final LinuxSocketMacros INSTANCE = new LinuxSocketMacros();
+
+    public int CMSG_ALIGN(int len) {
+        int sizeof_size_t = Runtime.getSystemRuntime().findType(TypeAlias.size_t).size();
+        return (len + sizeof_size_t - 1) & ~(sizeof_size_t - 1);
+    }
+
+    public int CMSG_SPACE(int l) {
+        return CMSG_ALIGN(l) + CMSG_ALIGN(LinuxCmsgHdr.layout.size());
+    }
+
+    public int CMSG_LEN(int l) {
+        return CMSG_ALIGN( LinuxCmsgHdr.layout.size() ) + l;
+    }
+
+    public Pointer CMSG_DATA(Pointer cmsg) {
+        return cmsg.slice(CMSG_ALIGN(LinuxCmsgHdr.layout.size()));
+    }
+}
diff --git a/src/main/java/jnr/posix/MacOSCmsgHdr.java b/src/main/java/jnr/posix/MacOSCmsgHdr.java
new file mode 100644
index 0000000..d75c934
--- /dev/null
+++ b/src/main/java/jnr/posix/MacOSCmsgHdr.java
@@ -0,0 +1,69 @@
+package jnr.posix;
+
+import jnr.ffi.Pointer;
+import jnr.ffi.Runtime;
+import jnr.ffi.StructLayout;
+
+/**
+ * @author Bob McWhirter
+ */
+class MacOSCmsgHdr extends BaseCmsgHdr {
+
+    public static class Layout extends StructLayout {
+
+        protected Layout(Runtime runtime) {
+            super(runtime);
+        }
+
+        public final Unsigned32 cmsg_len = new Unsigned32();
+        public final Signed32 cmsg_level = new Signed32();
+        public final Signed32 cmsg_type = new Signed32();
+    }
+
+    public static final Layout layout = new Layout(Runtime.getSystemRuntime());
+
+    public MacOSCmsgHdr(NativePOSIX posix, Pointer memory) {
+        super(posix, memory);
+    }
+
+    public MacOSCmsgHdr(NativePOSIX posix, Pointer memory, int totalLen) {
+        super(posix, memory, totalLen );
+    }
+
+    public void setLevel(int level) {
+        layout.cmsg_level.set(this.memory, level);
+    }
+
+    public int getLevel() {
+        return layout.cmsg_level.get(this.memory);
+    }
+
+    public void setType(int type) {
+        layout.cmsg_type.set(this.memory, type);
+    }
+
+    public int getType() {
+        return layout.cmsg_type.get(this.memory);
+    }
+
+    public int getLen() {
+        return (int) layout.cmsg_len.get(this.memory);
+    }
+
+    void setLen(int len) {
+        layout.cmsg_len.set(this.memory, len);
+    }
+
+    public String toString(String indent) {
+        StringBuffer buf = new StringBuffer();
+
+        buf.append(indent).append("cmsg {\n");
+        buf.append(indent).append("  cmsg_len=").append(layout.cmsg_len.get(this.memory)).append("\n");
+        buf.append(indent).append("  cmsg_level=").append(layout.cmsg_level.get(this.memory)).append("\n");
+        buf.append(indent).append("  cmsg_type=").append(layout.cmsg_type.get(this.memory)).append("\n");
+        buf.append(indent).append("  cmsg_data=").append(getData()).append("\n");
+        buf.append(indent).append("}");
+        return buf.toString();
+    }
+
+}
diff --git a/src/main/java/jnr/posix/MacOSFileStat.java b/src/main/java/jnr/posix/MacOSFileStat.java
new file mode 100644
index 0000000..e9f42f2
--- /dev/null
+++ b/src/main/java/jnr/posix/MacOSFileStat.java
@@ -0,0 +1,139 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * 
+ *  
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+
+public final class MacOSFileStat extends BaseFileStat implements NanosecondFileStat {
+    public static class Layout extends StructLayout {
+
+        public Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final class time_t extends SignedLong {
+        }
+        public final Signed32 st_dev = new Signed32();
+        public final Signed32 st_ino = new Signed32();
+        public final Signed16 st_mode = new Signed16();
+        public final Signed16 st_nlink = new Signed16();
+        public final Signed32 st_uid = new Signed32();
+        public final Signed32 st_gid = new Signed32();
+        public final Signed32 st_rdev = new Signed32();
+        public final time_t st_atime = new time_t();
+        public final SignedLong st_atimensec = new SignedLong();
+        public final time_t st_mtime = new time_t();
+        public final SignedLong st_mtimensec = new SignedLong();
+        public final time_t st_ctime = new time_t();
+        public final SignedLong st_ctimensec = new SignedLong();
+        public final Signed64 st_size = new Signed64();
+        public final Signed64 st_blocks = new Signed64();
+        public final Signed32 st_blksize = new Signed32();
+        public final Signed32 st_flags = new Signed32();
+        public final Signed32 st_gen = new Signed32();
+        public final Signed32 st_lspare = new Signed32();
+        public final Signed64 st_qspare0 = new Signed64();
+        public final Signed64 st_qspare1 = new Signed64();
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public MacOSFileStat(MacOSPOSIX posix) {
+        super(posix, layout);
+    }
+
+    public long atime() {
+        return layout.st_atime.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctime.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return layout.st_mode.get(memory) & 0xffff;
+    }
+
+    public long mtime() {
+        return layout.st_mtime.get(memory);
+    }
+
+    public int nlink() {
+        return layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout.st_size.get(memory);
+    }
+
+    public int uid() {
+        return layout.st_uid.get(memory);
+    }
+
+    @Override
+    public long aTimeNanoSecs() {
+        return layout.st_atimensec.get(memory);
+    }
+
+    @Override
+    public long cTimeNanoSecs() {
+        return layout.st_ctimensec.get(memory);
+    }
+
+    @Override
+    public long mTimeNanoSecs() {
+        return layout.st_mtimensec.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/MacOSFileStat64Inode.java b/src/main/java/jnr/posix/MacOSFileStat64Inode.java
new file mode 100644
index 0000000..703830a
--- /dev/null
+++ b/src/main/java/jnr/posix/MacOSFileStat64Inode.java
@@ -0,0 +1,144 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * 
+ *  
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+
+/**
+ * An alternate stat layout when running with _DARWIN_FEATURE_64_BIT_INODE, which appears to be the default on M1.
+ */
+public final class MacOSFileStat64Inode extends BaseFileStat implements NanosecondFileStat {
+    public static class Layout64Inode extends StructLayout {
+
+        public Layout64Inode(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final class time_t extends SignedLong {
+        }
+        public final Signed32 st_dev = new Signed32();
+        public final Signed16 st_mode = new Signed16();
+        public final Signed16 st_nlink = new Signed16();
+        public final Signed64 st_ino = new Signed64();
+        public final Signed32 st_uid = new Signed32();
+        public final Signed32 st_gid = new Signed32();
+        public final Signed32 st_rdev = new Signed32();
+        public final time_t st_atime = new time_t();
+        public final SignedLong st_atimensec = new SignedLong();
+        public final time_t st_mtime = new time_t();
+        public final SignedLong st_mtimensec = new SignedLong();
+        public final time_t st_ctime = new time_t();
+        public final SignedLong st_ctimensec = new SignedLong();
+        public final time_t st_birthtime = new time_t();
+        public final SignedLong st_birthtimensec = new SignedLong();
+        public final Signed64 st_size = new Signed64();
+        public final Signed64 st_blocks = new Signed64();
+        public final Signed32 st_blksize = new Signed32();
+        public final Signed32 st_flags = new Signed32();
+        public final Signed32 st_gen = new Signed32();
+        public final Signed32 st_lspare = new Signed32();
+        public final Signed64 st_qspare0 = new Signed64();
+        public final Signed64 st_qspare1 = new Signed64();
+    }
+    private static final Layout64Inode layout = new Layout64Inode(jnr.ffi.Runtime.getSystemRuntime());
+
+    public MacOSFileStat64Inode(MacOSPOSIX posix) {
+        super(posix, layout);
+    }
+
+    public long atime() {
+        return layout.st_atime.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctime.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return layout.st_mode.get(memory) & 0xffff;
+    }
+
+    public long mtime() {
+        return layout.st_mtime.get(memory);
+    }
+
+    public int nlink() {
+        return layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout.st_size.get(memory);
+    }
+
+    public int uid() {
+        return layout.st_uid.get(memory);
+    }
+
+    @Override
+    public long aTimeNanoSecs() {
+        return layout.st_atimensec.get(memory);
+    }
+
+    @Override
+    public long cTimeNanoSecs() {
+        return layout.st_ctimensec.get(memory);
+    }
+
+    @Override
+    public long mTimeNanoSecs() {
+        return layout.st_mtimensec.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/MacOSMsgHdr.java b/src/main/java/jnr/posix/MacOSMsgHdr.java
new file mode 100644
index 0000000..b8a1f36
--- /dev/null
+++ b/src/main/java/jnr/posix/MacOSMsgHdr.java
@@ -0,0 +1,151 @@
+package jnr.posix;
+
+import jnr.ffi.Pointer;
+import jnr.ffi.Runtime;
+import jnr.ffi.StructLayout;
+
+import java.nio.ByteBuffer;
+
+/**
+ * @author Bob McWhirter
+ */
+class MacOSMsgHdr extends BaseMsgHdr {
+
+    public static class Layout extends StructLayout {
+        protected Layout(Runtime runtime) {
+            super(runtime);
+        }
+
+        public final Pointer msg_name = new Pointer();
+        public final socklen_t msg_namelen = new socklen_t();
+        public final Pointer msg_iov = new Pointer();
+        public final Signed32 msg_iovlen = new Signed32();
+        public final Pointer msg_control = new Pointer();
+        public final socklen_t msg_controllen = new socklen_t();
+        public final Signed32 msg_flags = new Signed32();
+    }
+
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    protected MacOSMsgHdr(NativePOSIX posix) {
+        super(posix, layout);
+        setName(null);
+    }
+
+    CmsgHdr allocateCmsgHdrInternal(NativePOSIX posix, Pointer pointer, int len) {
+        if (len > 0) {
+            return new MacOSCmsgHdr(posix, pointer, len);
+        } else {
+            return new MacOSCmsgHdr(posix, pointer);
+        }
+    }
+
+    @Override
+    void setControlPointer(Pointer control) {
+        layout.msg_control.set(this.memory, control);
+    }
+
+    @Override
+    void setControlLen(int len) {
+        layout.msg_controllen.set(this.memory, len);
+    }
+
+    public String toString() {
+        StringBuffer buf = new StringBuffer();
+        buf.append("msghdr {\n");
+        buf.append("  msg_name=").append(getName()).append(",\n");
+        buf.append("  msg_namelen=").append(getNameLen()).append(",\n");
+
+        buf.append("  msg_iov=[\n");
+        Pointer iovp = layout.msg_iov.get(this.memory);
+
+        int numIov = getIovLen();
+        for (int i = 0; i < numIov; ++i) {
+            Pointer eachp = iovp.slice(i * BaseIovec.layout.size());
+            buf.append(new BaseIovec(posix, eachp).toString("    "));
+            if (i < (numIov - 1)) {
+                buf.append(",\n");
+            } else {
+                buf.append("\n");
+            }
+        }
+        buf.append("  ],\n");
+
+        buf.append("  msg_control=[\n");
+
+        CmsgHdr[] controls = getControls();
+        for (int i = 0; i < controls.length; ++i) {
+            buf.append(((MacOSCmsgHdr) controls[i]).toString("    "));
+            if (i < controls.length - 1) {
+                buf.append(",\n");
+            } else {
+                buf.append("\n");
+            }
+        }
+        buf.append("  ],\n");
+        buf.append("  msg_controllen=").append(layout.msg_controllen.get(this.memory)).append("\n");
+
+        buf.append("  msg_iovlen=").append(getIovLen()).append(",\n");
+        buf.append("  msg_flags=").append(getFlags()).append(",\n");
+        buf.append("}");
+        return buf.toString();
+    }
+
+    @Override
+    void setNamePointer(Pointer name) {
+        layout.msg_name.set( this.memory, name );
+    }
+
+    @Override
+    Pointer getNamePointer() {
+        return layout.msg_name.get( this.memory );
+    }
+
+
+    @Override
+    void setNameLen(int len) {
+        layout.msg_namelen.set(this.memory, len);
+    }
+
+    @Override
+    int getNameLen() {
+        return (int) layout.msg_namelen.get(this.memory);
+    }
+
+    @Override
+    void setIovPointer(Pointer iov) {
+        layout.msg_iov.set(this.memory, iov);
+    }
+
+    @Override
+    Pointer getIovPointer() {
+        return layout.msg_iov.get( this.memory );
+    }
+
+    @Override
+    void setIovLen(int len) {
+        layout.msg_iovlen.set(this.memory, len);
+    }
+
+    @Override
+    int getIovLen() {
+        return layout.msg_iovlen.get(this.memory);
+    }
+
+    @Override
+    Pointer getControlPointer() {
+        return layout.msg_control.get(this.memory);
+    }
+
+    public int getControlLen() {
+        return (int) layout.msg_controllen.get(this.memory);
+    }
+
+    public void setFlags(int flags) {
+        layout.msg_flags.set(this.memory, flags);
+    }
+
+    public int getFlags() {
+        return layout.msg_flags.get(this.memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/MacOSPOSIX.java b/src/main/java/jnr/posix/MacOSPOSIX.java
new file mode 100644
index 0000000..d505317
--- /dev/null
+++ b/src/main/java/jnr/posix/MacOSPOSIX.java
@@ -0,0 +1,75 @@
+package jnr.posix;
+
+import java.nio.ByteBuffer;
+import jnr.constants.platform.Confstr;
+import jnr.constants.platform.Pathconf;
+import jnr.constants.platform.Sysconf;
+import jnr.ffi.*;
+import jnr.ffi.mapper.FromNativeContext;
+
+
+final class MacOSPOSIX extends BaseNativePOSIX {
+
+    private final NSGetEnviron environ;
+
+    MacOSPOSIX(LibCProvider libcProvider, POSIXHandler handler) {
+        super(libcProvider, handler);
+
+        final LibraryLoader<NSGetEnviron> loader = LibraryLoader.create(NSGetEnviron.class);
+        loader.library("libSystem.B.dylib");
+        environ = loader.load();
+    }
+
+    public FileStat allocateStat() {
+        if (Platform.getNativePlatform().getCPU() == Platform.CPU.AARCH64) {
+            return new MacOSFileStat64Inode(this);
+        }
+
+        return new MacOSFileStat(this);
+    }
+
+    public MsgHdr allocateMsgHdr() {
+        return new MacOSMsgHdr(this);
+    }
+
+    @Override
+    public Pointer allocatePosixSpawnFileActions() {
+        return Memory.allocateDirect(getRuntime(), 8);
+    }
+
+    @Override
+    public Pointer allocatePosixSpawnattr() {
+        return Memory.allocateDirect(getRuntime(), 8);
+    }
+
+    public SocketMacros socketMacros() {
+        return MacOSSocketMacros.INSTANCE;
+    }
+
+    public long sysconf(Sysconf name) {
+        return libc().sysconf(name);
+    }
+
+    public int confstr(Confstr name, ByteBuffer buf, int len) {
+        return libc().confstr(name, buf, len);
+    }
+
+    public int fpathconf(int fd, Pathconf name) {
+        return libc().fpathconf(fd, name);
+    }
+
+    public Times times() {
+        return NativeTimes.times(this);
+    }
+
+    @Override
+    public Pointer environ() {
+        return environ._NSGetEnviron().getPointer(0);
+    }
+
+    public static final PointerConverter PASSWD = new PointerConverter() {
+        public Object fromNative(Object arg, FromNativeContext ctx) {
+            return arg != null ? new MacOSPasswd((Pointer) arg) : null;
+        }
+    };
+}
diff --git a/src/main/java/jnr/posix/MacOSPasswd.java b/src/main/java/jnr/posix/MacOSPasswd.java
new file mode 100644
index 0000000..16f21ee
--- /dev/null
+++ b/src/main/java/jnr/posix/MacOSPasswd.java
@@ -0,0 +1,74 @@
+
+
+package jnr.posix;
+
+
+import jnr.ffi.StructLayout;
+
+/**
+ *
+ */
+public final class MacOSPasswd extends NativePasswd implements Passwd {
+    private static final class Layout extends StructLayout {
+
+        private Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final UTF8StringRef pw_name = new UTF8StringRef();   // user name
+        public final UTF8StringRef pw_passwd = new UTF8StringRef(); // password (encrypted)
+        public final Signed32 pw_uid = new Signed32();       // user id
+        public final Signed32 pw_gid = new Signed32();       // user id
+        public final SignedLong pw_change = new SignedLong();    // password change time
+        public final UTF8StringRef pw_class = new UTF8StringRef();  // user access class
+        public final UTF8StringRef pw_gecos = new UTF8StringRef();  // login info
+        public final UTF8StringRef pw_dir = new UTF8StringRef();    // home directory
+        public final UTF8StringRef pw_shell = new UTF8StringRef();  // default shell
+        public final SignedLong pw_expire = new SignedLong();    // account expiration
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+    
+    MacOSPasswd(jnr.ffi.Pointer memory) {
+        super(memory);
+    }
+    
+    public java.lang.String getAccessClass() {
+        return layout.pw_class.get(memory);
+    }
+    
+    public java.lang.String getGECOS() {
+        return layout.pw_gecos.get(memory);
+    }
+    
+    public long getGID() {
+        return layout.pw_gid.get(memory);
+    }
+    
+    public java.lang.String getHome() {
+        return layout.pw_dir.get(memory);
+    }
+    
+    public java.lang.String getLoginName() {
+        return layout.pw_name.get(memory);
+    }
+    
+    public int getPasswdChangeTime() {
+        return layout.pw_change.intValue(memory);
+    }
+    
+    public java.lang.String getPassword() {
+        return layout.pw_passwd.get(memory);
+    }
+    
+    public java.lang.String getShell() {
+        return layout.pw_shell.get(memory);
+    }
+    
+    public long getUID() {
+        return layout.pw_uid.get(memory);
+    }
+    
+    public int getExpire() {
+        return layout.pw_expire.intValue(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/MacOSSocketMacros.java b/src/main/java/jnr/posix/MacOSSocketMacros.java
new file mode 100644
index 0000000..c33f239
--- /dev/null
+++ b/src/main/java/jnr/posix/MacOSSocketMacros.java
@@ -0,0 +1,27 @@
+package jnr.posix;
+
+import jnr.ffi.Pointer;
+
+/**
+ * @author Bob McWhirter
+ */
+public class MacOSSocketMacros implements SocketMacros {
+
+    public static final SocketMacros INSTANCE = new MacOSSocketMacros();
+
+    public int __DARWIN_ALIGN32(int x) {
+        return ((x + 3) & ~3);
+    }
+
+    public int CMSG_SPACE(int l) {
+        return __DARWIN_ALIGN32(MacOSCmsgHdr.layout.size()) + __DARWIN_ALIGN32(l);
+    }
+
+    public int CMSG_LEN(int l) {
+        return (__DARWIN_ALIGN32(MacOSCmsgHdr.layout.size())) + (l);
+    }
+
+    public Pointer CMSG_DATA(Pointer cmsg) {
+        return cmsg.slice(__DARWIN_ALIGN32(MacOSCmsgHdr.layout.size()));
+    }
+}
diff --git a/src/main/java/jnr/posix/MsgHdr.java b/src/main/java/jnr/posix/MsgHdr.java
new file mode 100644
index 0000000..ffac87e
--- /dev/null
+++ b/src/main/java/jnr/posix/MsgHdr.java
@@ -0,0 +1,25 @@
+package jnr.posix;
+
+import java.nio.ByteBuffer;
+
+/**
+ * @author Bob McWhirter
+ */
+public interface MsgHdr {
+
+    void setName(String name);
+    String getName();
+
+    void setIov(ByteBuffer[] buffers);
+    ByteBuffer[] getIov();
+
+
+    void setFlags(int flags);
+    int getFlags();
+
+    CmsgHdr allocateControl(int dataLength);
+    CmsgHdr[] allocateControls(int[] dataLengths);
+
+    CmsgHdr[] getControls();
+    int getControlLen();
+}
diff --git a/src/main/java/jnr/posix/NSGetEnviron.java b/src/main/java/jnr/posix/NSGetEnviron.java
new file mode 100644
index 0000000..4abe8c4
--- /dev/null
+++ b/src/main/java/jnr/posix/NSGetEnviron.java
@@ -0,0 +1,9 @@
+package jnr.posix;
+
+import jnr.ffi.Pointer;
+
+public interface NSGetEnviron {
+
+    Pointer _NSGetEnviron();
+
+}
diff --git a/src/main/java/jnr/posix/NanosecondFileStat.java b/src/main/java/jnr/posix/NanosecondFileStat.java
new file mode 100644
index 0000000..00f1e96
--- /dev/null
+++ b/src/main/java/jnr/posix/NanosecondFileStat.java
@@ -0,0 +1,12 @@
+package jnr.posix;
+
+/**
+ * Represents the additional nsec resolution on the stat struct in Linux 2.6+.
+ */
+public interface NanosecondFileStat extends FileStat {
+    long aTimeNanoSecs();
+
+    long cTimeNanoSecs();
+
+    long mTimeNanoSecs();
+}
diff --git a/src/main/java/jnr/posix/NativeGroup.java b/src/main/java/jnr/posix/NativeGroup.java
new file mode 100644
index 0000000..964f3b4
--- /dev/null
+++ b/src/main/java/jnr/posix/NativeGroup.java
@@ -0,0 +1,12 @@
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+
+public abstract class NativeGroup implements Group {
+    protected final jnr.ffi.Runtime runtime;
+    protected final StructLayout structLayout;
+    protected NativeGroup(jnr.ffi.Runtime runtime, StructLayout structLayout) {
+        this.runtime = runtime;
+        this.structLayout = structLayout;
+    }
+}
diff --git a/src/main/java/jnr/posix/NativePOSIX.java b/src/main/java/jnr/posix/NativePOSIX.java
new file mode 100644
index 0000000..6c32fc5
--- /dev/null
+++ b/src/main/java/jnr/posix/NativePOSIX.java
@@ -0,0 +1,26 @@
+package jnr.posix;
+
+import jnr.ffi.Memory;
+import jnr.ffi.Pointer;
+
+/**
+ *
+ */
+public abstract class NativePOSIX implements POSIX {
+
+
+    jnr.ffi.Runtime getRuntime() {
+        return jnr.ffi.Runtime.getRuntime(libc());
+    }
+
+    public abstract SocketMacros socketMacros();
+
+    public Pointer allocatePosixSpawnFileActions() {
+        return Memory.allocateDirect(getRuntime(), 128);
+    }
+
+    public Pointer allocatePosixSpawnattr() {
+        return Memory.allocateDirect(getRuntime(), 128);
+    }
+
+}
diff --git a/src/main/java/jnr/posix/NativePasswd.java b/src/main/java/jnr/posix/NativePasswd.java
new file mode 100644
index 0000000..49a7dd4
--- /dev/null
+++ b/src/main/java/jnr/posix/NativePasswd.java
@@ -0,0 +1,12 @@
+package jnr.posix;
+
+import jnr.ffi.Pointer;
+
+
+public abstract class NativePasswd implements Passwd {
+    protected final Pointer memory;
+
+    NativePasswd(jnr.ffi.Pointer pointer) {
+        this.memory = pointer;
+    }
+}
diff --git a/src/main/java/jnr/posix/NativeTimes.java b/src/main/java/jnr/posix/NativeTimes.java
new file mode 100644
index 0000000..68a4252
--- /dev/null
+++ b/src/main/java/jnr/posix/NativeTimes.java
@@ -0,0 +1,51 @@
+package jnr.posix;
+
+import jnr.constants.platform.Errno;
+import jnr.ffi.LastError;
+import jnr.ffi.Memory;
+import jnr.ffi.Pointer;
+import jnr.ffi.StructLayout;
+
+/**
+ *
+ */
+public final class NativeTimes implements Times {
+    static final class Layout extends StructLayout {
+        public final clock_t tms_utime = new clock_t();
+        public final clock_t tms_stime = new clock_t();
+        public final clock_t tms_cutime = new clock_t();
+        public final clock_t tms_cstime = new clock_t();
+
+        Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+    }
+
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+    final Pointer memory;
+
+    static NativeTimes times(BaseNativePOSIX posix) {
+        NativeTimes tms = new NativeTimes(posix);
+        return posix.libc().times(tms) == -1 ? null : tms;
+    }
+
+    NativeTimes(NativePOSIX posix) {
+        this.memory = Memory.allocate(posix.getRuntime(), layout.size());
+    }
+
+    public long utime() {
+        return layout.tms_utime.get(memory);
+    }
+
+    public long stime() {
+        return layout.tms_stime.get(memory);
+    }
+
+    public long cutime() {
+        return layout.tms_cutime.get(memory);
+    }
+
+    public long cstime() {
+        return layout.tms_cstime.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/OpenBSDFileStat.java b/src/main/java/jnr/posix/OpenBSDFileStat.java
new file mode 100644
index 0000000..fc4732d
--- /dev/null
+++ b/src/main/java/jnr/posix/OpenBSDFileStat.java
@@ -0,0 +1,138 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+
+public final class OpenBSDFileStat extends BaseFileStat implements NanosecondFileStat{
+    private static final class Layout extends StructLayout {
+
+        private Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final class time_t extends Signed64 {}
+        public final class dev_t extends Signed32 {}
+
+        public final Unsigned32  st_mode = new Unsigned32();
+        public final dev_t  st_dev = new dev_t();
+        public final Unsigned64  st_ino = new Unsigned64();
+        public final Unsigned32  st_nlink = new Unsigned32();
+        public final Unsigned32  st_uid = new Unsigned32();
+        public final Unsigned32  st_gid = new Unsigned32();
+        public final dev_t  st_rdev = new dev_t();
+        public final time_t st_atime = new time_t();
+        public final SignedLong   st_atimensec = new SignedLong();
+        public final time_t st_mtime = new time_t();
+        public final SignedLong   st_mtimensec = new SignedLong();
+        public final time_t st_ctime = new time_t();
+        public final SignedLong   st_ctimensec = new SignedLong();
+        public final Signed64  st_size = new Signed64();
+        public final Signed64  st_blocks = new Signed64();
+        public final Unsigned32  st_blksize = new Unsigned32();
+        public final Unsigned32  st_flags = new Unsigned32();
+        public final Unsigned32  st_gen = new Unsigned32();
+        public final time_t st_birthtime = new time_t();
+        public final SignedLong   st_birthtimensec = new SignedLong();
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+    public OpenBSDFileStat(NativePOSIX posix) {
+        super(posix, layout);
+    }
+    
+    public long atime() {
+        return layout.st_atime.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctime.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return (int) layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return (int)(layout.st_mode.get(memory) & 0xffff);
+    }
+
+    public long mtime() {
+        return layout.st_mtime.get(memory);
+    }
+
+    public int nlink() {
+        return (int)layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout.st_size.get(memory);
+    }
+
+    public int uid() {
+        return (int)layout.st_uid.get(memory);
+    }
+
+    @Override
+    public long aTimeNanoSecs() {
+        return layout.st_atimensec.get(memory);
+    }
+
+    @Override
+    public long cTimeNanoSecs() {
+        return layout.st_ctimensec.get(memory);
+    }
+
+    @Override
+    public long mTimeNanoSecs() {
+        return layout.st_mtimensec.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/OpenBSDPOSIX.java b/src/main/java/jnr/posix/OpenBSDPOSIX.java
new file mode 100644
index 0000000..e3ca82e
--- /dev/null
+++ b/src/main/java/jnr/posix/OpenBSDPOSIX.java
@@ -0,0 +1,103 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+import java.nio.ByteBuffer;
+import jnr.constants.platform.Confstr;
+import jnr.constants.platform.Pathconf;
+import jnr.constants.platform.Sysconf;
+import jnr.ffi.Memory;
+import jnr.ffi.Struct;
+import jnr.ffi.mapper.FromNativeContext;
+import jnr.ffi.Pointer;
+import jnr.posix.util.MethodName;
+
+final class OpenBSDPOSIX extends BaseNativePOSIX {
+    OpenBSDPOSIX(LibCProvider libc, POSIXHandler handler) {
+        super(libc, handler);
+    }
+    
+    public FileStat allocateStat() {
+        return new OpenBSDFileStat(this);
+    }
+
+    public MsgHdr allocateMsgHdr() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return null;
+    }
+
+    public SocketMacros socketMacros() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return null;
+    }
+
+    public long sysconf(Sysconf name) {
+        return libc().sysconf(name);
+    }
+
+    public int confstr(Confstr name, ByteBuffer buf, int len) {
+        return libc().confstr(name, buf, len);
+    }
+
+    public int fpathconf(int fd, Pathconf name) {
+        return libc().fpathconf(fd, name);
+    }
+
+    public Times times() {
+        return NativeTimes.times(this);
+    }
+    
+    public static final PointerConverter PASSWD = new PointerConverter() {
+        public Object fromNative(Object arg, FromNativeContext ctx) {
+            return arg != null ? new OpenBSDPasswd((Pointer) arg) : null;
+        }
+    };
+
+    @Override
+    public int utimes(String path, long[] atimeval, long[] mtimeval) {
+        Timeval[] times = null;
+        if (atimeval != null && mtimeval != null) {
+            times = Struct.arrayOf(getRuntime(), OpenBSDTimeval.class, 2);
+            times[0].setTime(atimeval);
+            times[1].setTime(mtimeval);
+        }
+        return libc().utimes(path, times);
+    }
+
+    public Pointer allocatePosixSpawnFileActions() {
+        return Memory.allocateDirect(getRuntime(), 8);
+    }
+
+    public Pointer allocatePosixSpawnattr() {
+        return Memory.allocateDirect(getRuntime(), 8);
+    }
+}
diff --git a/src/main/java/jnr/posix/OpenBSDPasswd.java b/src/main/java/jnr/posix/OpenBSDPasswd.java
new file mode 100644
index 0000000..4c61681
--- /dev/null
+++ b/src/main/java/jnr/posix/OpenBSDPasswd.java
@@ -0,0 +1,100 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+
+import jnr.ffi.StructLayout;
+
+public class OpenBSDPasswd extends NativePasswd implements Passwd {
+    private static final class Layout extends StructLayout {
+
+        private Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final UTF8StringRef pw_name = new UTF8StringRef();   // user name
+        public final UTF8StringRef pw_passwd = new UTF8StringRef(); // password (encrypted)
+        public final Unsigned32 pw_uid = new Unsigned32();       // user id
+        public final Unsigned32 pw_gid = new Unsigned32();       // user id
+        public final Signed64 pw_change = new Signed64();    // password change time
+        public final UTF8StringRef pw_class = new UTF8StringRef();  // user access class
+        public final UTF8StringRef pw_gecos = new UTF8StringRef();  // login info
+        public final UTF8StringRef pw_dir = new UTF8StringRef();    // home directory
+        public final UTF8StringRef pw_shell = new UTF8StringRef();  // default shell
+        public final Signed64 pw_expire = new Signed64();    // account expiration
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    OpenBSDPasswd(jnr.ffi.Pointer memory) {
+        super(memory);
+    }
+
+    public java.lang.String getAccessClass() {
+        return layout.pw_class.get(memory);
+    }
+
+    public java.lang.String getGECOS() {
+        return layout.pw_gecos.get(memory);
+    }
+
+    public long getGID() {
+        return layout.pw_gid.get(memory);
+    }
+
+    public java.lang.String getHome() {
+        return layout.pw_dir.get(memory);
+    }
+
+    public java.lang.String getLoginName() {
+        return layout.pw_name.get(memory);
+    }
+
+    public int getPasswdChangeTime() {
+        return layout.pw_change.intValue(memory);
+    }
+
+    public java.lang.String getPassword() {
+        return layout.pw_passwd.get(memory);
+    }
+
+    public java.lang.String getShell() {
+        return layout.pw_shell.get(memory);
+    }
+
+    public long getUID() {
+        return layout.pw_uid.get(memory);
+    }
+
+    public int getExpire() {
+        return layout.pw_expire.intValue(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/OpenBSDTimeval.java b/src/main/java/jnr/posix/OpenBSDTimeval.java
new file mode 100644
index 0000000..734d456
--- /dev/null
+++ b/src/main/java/jnr/posix/OpenBSDTimeval.java
@@ -0,0 +1,32 @@
+package jnr.posix;
+
+public final class OpenBSDTimeval extends Timeval {
+    public final Signed64 tv_sec = new Signed64();
+    public final SignedLong tv_usec = new SignedLong();
+
+    public OpenBSDTimeval(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+
+    public void setTime(long[] timeval) {
+        assert timeval.length == 2;
+        tv_sec.set(timeval[0]);
+        tv_usec.set(timeval[1]);
+    }
+
+    public void sec(long sec) {
+        this.tv_sec.set(sec);
+    }
+
+    public void usec(long usec) {
+        this.tv_usec.set(usec);
+    }
+
+    public long sec() {
+        return tv_sec.get();
+    }
+
+    public long usec() {
+        return tv_usec.get();
+    }
+}
diff --git a/src/main/java/jnr/posix/POSIX.java b/src/main/java/jnr/posix/POSIX.java
new file mode 100644
index 0000000..941067d
--- /dev/null
+++ b/src/main/java/jnr/posix/POSIX.java
@@ -0,0 +1,237 @@
+package jnr.posix;
+
+import jnr.constants.platform.Fcntl;
+import jnr.constants.platform.Signal;
+import jnr.constants.platform.Sysconf;
+import jnr.ffi.Pointer;
+import jnr.posix.util.ProcessMaker;
+
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import jnr.constants.platform.Confstr;
+import jnr.constants.platform.Pathconf;
+import jnr.ffi.annotations.Out;
+
+public interface POSIX {
+    CharSequence crypt(CharSequence key, CharSequence salt);
+
+    /**
+     * Call the crypt function with the given key and salt as raw null-terminated byte (C char) strings.
+     *
+     * @param key null-terminated key bytes
+     * @param salt null-terminated salt bytes
+     * @return null-terminated crypted bytes, or null if there was an error
+     */
+    byte[] crypt(byte[] key, byte[] salt);
+
+    FileStat allocateStat();
+    int chmod(String filename, int mode);
+    int fchmod(int fd, int mode);
+    int chown(String filename, int user, int group);
+    int fchown(int fd, int user, int group);
+    /**
+     * Shell expanding and escaping version of exec which handles all the
+     * preparation of a command line or command list.
+     *
+     * @param path the path to execute
+     * @param argv the arguments to pass, with arg0 equal to the desired process name
+     * @return does not return if successful; -1 if failed
+     */
+    int exec(String path, String... argv);
+    
+    /**
+     * Shell expanding and escaping version of exec which handles all the
+     * preparation of a command line or command list.
+     *
+     * @param path the path to execute
+     * @param argv the arguments to pass, with arg0 equal to the desired process name
+     * @param envp a set of KEY=VALUE environment strings to set for the new execution
+     * @return does not return if successful; -1 if failed
+     */
+    int exec(String path, String[] argv, String[] envp);
+    
+    int execv(String path, String[] argv);  
+    int execve(String path, String[] argv, String[] envp);    
+    int fork();
+    FileStat fstat(FileDescriptor descriptor);
+    FileStat fstat(int descriptor);
+    int fstat(FileDescriptor descriptor, FileStat stat);
+    int fstat(int fd, FileStat stat);
+    Pointer environ();
+    String getenv(String envName);
+    int getegid();
+    int geteuid();
+    int seteuid(int euid);
+    int getgid();
+    int getdtablesize();
+    String getlogin();
+    int getpgid();
+    int getpgid(int pid);
+    int getpgrp();
+    int getpid();
+    int getppid();
+    int getpriority(int which, int who);
+    Passwd getpwent();
+    Passwd getpwuid(int which);
+    Passwd getpwnam(String which);
+    Group getgrgid(int which);
+    Group getgrnam(String which);
+    Group getgrent();
+    int endgrent();
+    int setgrent();
+    int endpwent();
+    int setpwent();
+    int getuid();
+    int getrlimit(int resource, RLimit rlim);
+    int getrlimit(int resource, Pointer rlim);
+    RLimit getrlimit(int resource);
+    int setrlimit(int resource, RLimit rlim);
+    int setrlimit(int resource, Pointer rlim);
+    int setrlimit(int resource, long rlimCur, long rlimMax);
+    boolean isatty(FileDescriptor descriptor);
+    int isatty(int descriptor);
+    int kill(int pid, int signal);
+    int kill(long pid, int signal);
+    SignalHandler signal(Signal sig, SignalHandler handler);
+    int raise(int sig);
+    int lchmod(String filename, int mode);
+    int lchown(String filename, int user, int group);
+    int link(String oldpath,String newpath);
+    FileStat lstat(String path);
+    int lstat(String path, FileStat stat);
+    int mkdir(String path, int mode);
+    String readlink(String path) throws IOException;
+    int readlink(CharSequence path, byte[] buf, int bufsize);
+    int readlink(CharSequence path, ByteBuffer buf, int bufsize);
+    int readlink(CharSequence path, Pointer bufPtr, int bufsize);
+    int rmdir(String path);
+    int setenv(String envName, String envValue, int overwrite); // 0 no !0 yes
+    int setsid();
+    int setgid(int gid);
+    int setegid(int egid);
+    int setpgid(int pid, int pgid);
+    int setpgrp(int pid, int pgrp);
+    int setpriority(int which, int who, int prio);
+    int setuid(int uid);
+    FileStat stat(String path);
+    int stat(String path, FileStat stat);
+    int symlink(String oldpath,String newpath);
+    int umask(int mask);
+    int unsetenv(String envName);
+    int utimes(String path, long[] atimeval, long[] mtimeval);
+    int utimes(String path, Pointer times);
+    int futimes(int fd, long[] atimeval, long[] mtimeval);
+    int lutimes(String path, long[] atimeval, long[] mtimeval);
+    int utimensat(int dirfd, String path, long[] atimespec, long[] mtimespec, int flag);
+    int utimensat(int dirfd, String path, Pointer times, int flag);
+    int futimens(int fd, long[] atimespec, long[] mtimespec);
+    int futimens(int fd, Pointer times);
+    int waitpid(int pid, int[] status, int flags);
+    int waitpid(long pid, int[] status, int flags);
+    int wait(int[] status);
+    int errno();
+    void errno(int value);
+    String strerror(int code);
+    int chdir(String path);
+    boolean isNative();
+    /**
+     * Returns null if isNative returns false.
+     *
+     * @return the LibC implementation for this POSIX
+     */
+    LibC libc();
+    ProcessMaker newProcessMaker(String... command);
+    ProcessMaker newProcessMaker();
+
+    public long sysconf(Sysconf name);
+
+    public int confstr(Confstr name, @Out ByteBuffer buf, int len);
+
+    public int fpathconf(int fd, Pathconf name);
+
+    public Times times();
+
+    public long posix_spawnp(String path, Collection<? extends SpawnFileAction> fileActions,
+                            Collection<? extends CharSequence> argv, Collection<? extends CharSequence> envp);
+
+    public long posix_spawnp(String path, Collection<? extends SpawnFileAction> fileActions,
+                             Collection<? extends SpawnAttribute> spawnAttributes,
+                             Collection<? extends CharSequence> argv, Collection<? extends CharSequence> envp);
+    
+    public int flock(int fd, int operation);
+
+    int dup(int fd);
+
+    int dup2(int oldFd, int newFd);
+
+    int fcntlInt(int fd, Fcntl fcntlConst, int arg);
+    int fcntl(int fd, Fcntl fcntlConst, int arg);
+    int fcntl(int fd, Fcntl fcntlConst);
+    int access(CharSequence path, int amode);
+    int close(int fd);
+    int unlink(CharSequence path);
+    int open(CharSequence path, int flags, int perm);
+
+    long read(int fd, byte[] buf, long n);
+    long write(int fd, byte[] buf, long n);
+    long read(int fd, ByteBuffer buf, long n);
+    long write(int fd, ByteBuffer buf, long n);
+    long pread(int fd, byte[] buf, long n, long offset);
+    long pwrite(int fd, byte[] buf, long n, long offset);
+    long pread(int fd, ByteBuffer buf, long n, long offset);
+    long pwrite(int fd, ByteBuffer buf, long n, long offset);
+
+    int read(int fd, byte[] buf, int n);
+    int write(int fd, byte[] buf, int n);
+    int read(int fd, ByteBuffer buf, int n);
+    int write(int fd, ByteBuffer buf, int n);
+    int pread(int fd, byte[] buf, int n, int offset);
+    int pwrite(int fd, byte[] buf, int n, int offset);
+    int pread(int fd, ByteBuffer buf, int n, int offset);
+    int pwrite(int fd, ByteBuffer buf, int n, int offset);
+
+    int lseek(int fd, long offset, int whence);
+    long lseekLong(int fd, long offset, int whence);
+    int pipe(int[] fds);
+    int truncate(CharSequence path, long length);
+    int ftruncate(int fd, long offset);
+    int rename(CharSequence oldName, CharSequence newName);
+    String getcwd();
+    String gethostname();
+
+    int socketpair(int domain, int type, int protocol, int[] fds);
+    int sendmsg(int socket, MsgHdr message, int flags);
+    int recvmsg(int socket, MsgHdr message, int flags);
+
+    MsgHdr allocateMsgHdr();
+
+    /**
+     * fcntl(2)
+     *
+     * @deprecated This version does not pass args because jnr-ffi does not support variadic invocation.
+     * @see jnr.posix.POSIX#fcntlInt(int, jnr.constants.platform.Fcntl, int)
+     *
+     * @param fd the file descriptor on which to act
+     * @param fcntlConst the {@link Fcntl} enum value for the flag to set
+     * @param arg arguments for the flag or null if none
+     * @return 0 if success, -1 if error
+     */
+    @Deprecated
+    int fcntl(int fd, Fcntl fcntlConst, int... arg);
+    int fsync(int fd);
+    int fdatasync(int fd);
+    int mkfifo(String filename, int mode);
+
+    int daemon(int nochdir, int noclose);
+
+    long[] getgroups();
+    int getgroups(int size, int[] groups);
+
+    String nl_langinfo(int item);
+    String setlocale(int category, String locale);
+
+    Timeval allocateTimeval();
+    int gettimeofday(Timeval tv);
+}
diff --git a/src/main/java/jnr/posix/POSIXFactory.java b/src/main/java/jnr/posix/POSIXFactory.java
new file mode 100644
index 0000000..a1ea703
--- /dev/null
+++ b/src/main/java/jnr/posix/POSIXFactory.java
@@ -0,0 +1,342 @@
+package jnr.posix;
+
+import jnr.ffi.Library;
+import jnr.ffi.LibraryLoader;
+import jnr.ffi.LibraryOption;
+import jnr.ffi.Struct;
+
+import java.util.Collections;
+import java.util.HashMap;
+
+import jnr.ffi.mapper.FunctionMapper;
+import jnr.posix.util.DefaultPOSIXHandler;
+import jnr.posix.util.Platform;
+
+import java.util.Map;
+
+public class POSIXFactory {
+    // Weird inner-class resolution problem work-around FIXME: JRUBY-5889.  Someone fix JAFFL!
+    private static final Class<Struct> BOGUS_HACK = Struct.class;
+    public static final jnr.ffi.Platform NATIVE_PLATFORM = jnr.ffi.Platform.getNativePlatform();
+    public static final String STANDARD_C_LIBRARY_NAME = NATIVE_PLATFORM.getStandardCLibraryName();
+
+    /**
+     * Get a POSIX instance. If useNativePosix is true, this works just like
+     * POSIXFactory#getPOSIX(). If useNativePosix is false, this works like
+     * POSIXFactory#getJavaPOSIX()
+     *
+     * @param handler a POSIXHandler implementation
+     * @param useNativePOSIX whether to attempt to use native code for better functionality
+     * @return a POSIX implementation, attempting to use native code if useNativePosix is true
+     */
+    public static POSIX getPOSIX(POSIXHandler handler, boolean useNativePOSIX) {
+        return new LazyPOSIX(handler, useNativePOSIX);
+    }
+
+    /**
+     * This will use {@link DefaultPOSIXHandler} and the native POSIX implementation,
+     * falling back on the pure-Java implementation if native support is not available.
+     *
+     * @return a POSIX implementation, native if possible and pure-Java otherwise.
+     */
+    public static POSIX getPOSIX() {
+        return getPOSIX(new DefaultPOSIXHandler(), true);
+    }
+
+    /**
+     * Get a pure-Java POSIX instance. Functionality will be limited to that which can
+     * be provided by pure-Java/JDK features or shelling out to external commands.
+     *
+     * @param handler a POSIXHandler implementation
+     * @return a pure-Java POSIX implementation
+     */
+    public static POSIX getJavaPOSIX(POSIXHandler handler) {
+        return new JavaPOSIX(handler);
+    }
+
+    /**
+     * Get a pure-Java POSIX instance. Functionality will be limited to that which can
+     * be provided by pure-Java/JDK features or shelling out to external commands.
+     *
+     * @return a pure-Java POSIX implementation
+     */
+    public static POSIX getJavaPOSIX() {
+        return getJavaPOSIX(new DefaultPOSIXHandler());
+    }
+
+    /**
+     * Get a POSIX instance. If a true native implementation can't be loaded, allow that
+     * error to propagate rather than falling back on the pure-Java version.
+     *
+     * @param handler a POSIXHandler implementation
+     * @return a native POSIX implementation, raising errors if the native version can't load
+     */
+    public static POSIX getNativePOSIX(POSIXHandler handler) {
+        return loadNativePOSIX(handler);
+    }
+
+    /**
+     * Get a POSIX instance. If a true native implementation can't be loaded, allow that
+     * error to propagate rather than falling back on the pure-Java version.
+     *
+     * @return a native POSIX implementation, raising errors if the native version can't load
+     */
+    public static POSIX getNativePOSIX() {
+        return getNativePOSIX(new DefaultPOSIXHandler());
+    }
+
+    static POSIX loadPOSIX(POSIXHandler handler, boolean useNativePOSIX) {
+        POSIX posix = null;
+
+        if (useNativePOSIX) {
+            try {
+                posix = loadNativePOSIX(handler);
+                posix = posix != null ? new CheckedPOSIX(posix, handler) : null;
+                // ENEBO: Should printing be done through a handler+log method?
+                if (handler.isVerbose()) {
+                    if (posix != null) {
+                        System.err.println("Successfully loaded native POSIX impl.");
+                    } else {
+                        System.err.println("Failed to load native POSIX impl; falling back on Java impl. Unsupported OS.");
+                    }
+                }
+            } catch (Throwable t) {
+                if (handler.isVerbose()) {
+                    System.err.println("Failed to load native POSIX impl; falling back on Java impl. Stacktrace follows.");
+                    t.printStackTrace();
+                }
+            }
+        }
+
+        if (posix == null) {
+            posix = getJavaPOSIX(handler);
+        }
+
+        return posix;
+    }
+    
+    private static POSIX loadNativePOSIX(POSIXHandler handler) {
+        switch (NATIVE_PLATFORM.getOS()) {
+            case DARWIN:
+                return loadMacOSPOSIX(handler);
+
+            case LINUX:
+                return loadLinuxPOSIX(handler);
+
+            case FREEBSD:
+                return loadFreeBSDPOSIX(handler);
+
+            case DRAGONFLY:
+                return loadDragonFlyPOSIX(handler);
+            
+            case OPENBSD:
+                return loadOpenBSDPOSIX(handler);
+
+            case SOLARIS:
+                return loadSolarisPOSIX(handler);
+            
+            case AIX:
+                return loadAixPOSIX(handler);
+            
+            case WINDOWS:
+                return loadWindowsPOSIX(handler);
+        }
+
+        return null;
+    }
+
+    public static POSIX loadLinuxPOSIX(POSIXHandler handler) {
+        return new LinuxPOSIX(DefaultLibCProvider.INSTANCE, handler);
+    }
+
+    public static POSIX loadMacOSPOSIX(POSIXHandler handler) {
+        return new MacOSPOSIX(DefaultLibCProvider.INSTANCE, handler);
+    }
+
+    public static POSIX loadSolarisPOSIX(POSIXHandler handler) {
+        return new SolarisPOSIX(DefaultLibCProvider.INSTANCE, handler);
+    }
+
+    public static POSIX loadFreeBSDPOSIX(POSIXHandler handler) {
+        return new FreeBSDPOSIX(DefaultLibCProvider.INSTANCE, handler);
+    }
+
+    public static POSIX loadDragonFlyPOSIX(POSIXHandler handler) {
+        return new DragonFlyPOSIX(DefaultLibCProvider.INSTANCE, handler);
+    }
+
+    public static POSIX loadOpenBSDPOSIX(POSIXHandler handler) {
+        return new OpenBSDPOSIX(DefaultLibCProvider.INSTANCE, handler);
+    }
+
+    public static POSIX loadWindowsPOSIX(POSIXHandler handler) {
+        return new WindowsPOSIX(DefaultLibCProvider.INSTANCE, handler);
+    }
+
+    public static POSIX loadAixPOSIX(POSIXHandler handler) {
+        return new AixPOSIX(DefaultLibCProvider.INSTANCE, handler);
+    }
+    
+    private static String[] libraries() {
+        switch (NATIVE_PLATFORM.getOS()) {
+            case LINUX:
+                return new String[] {STANDARD_C_LIBRARY_NAME};
+
+            case SOLARIS:
+                return new String[] { "socket", "nsl", STANDARD_C_LIBRARY_NAME};
+
+            case DRAGONFLY:
+            case FREEBSD:
+            case NETBSD:
+                return new String[] {STANDARD_C_LIBRARY_NAME};
+            
+            case AIX:
+                return jnr.ffi.Runtime.getSystemRuntime().addressSize() == 4
+                    ? new String[] { "libc.a(shr.o)" }
+                    : new String[] { "libc.a(shr_64.o)" };
+            
+            case WINDOWS:
+                return new String[] { "msvcrt", "kernel32" };
+
+            default:
+                return new String[] {STANDARD_C_LIBRARY_NAME};
+        }
+    }
+    
+    private static Class<? extends LibC> libraryInterface() {
+        switch (NATIVE_PLATFORM.getOS()) {
+            case LINUX:
+                return LinuxLibC.class;
+            
+            case AIX:
+                return AixLibC.class;
+            
+            case SOLARIS:
+                return SolarisLibC.class;
+
+            case WINDOWS:
+                return WindowsLibC.class;
+
+            default:
+                return UnixLibC.class;
+        }
+    }
+
+    private static FunctionMapper functionMapper() {
+        switch (NATIVE_PLATFORM.getOS()) {
+            case AIX:
+                return new SimpleFunctionMapper.Builder()
+                        .map("stat", "stat64x")
+                        .map("fstat", "fstat64x")
+                        .map("lstat", "lstat64x")
+                        .map("stat64", "stat64x")
+                        .map("fstat64", "fstat64x")
+                        .map("lstat64", "lstat64x")
+                        .build();
+            
+            case WINDOWS:
+                return new SimpleFunctionMapper.Builder()
+                        .map("getpid", "_getpid")
+                        .map("chmod", "_chmod")
+                        .map("fstat", "_fstat64")
+                        .map("stat", "_stat64")
+                        .map("umask", "_umask")
+                        .map("isatty", "_isatty")
+                        .map("read", "_read")
+                        .map("write", "_write")
+                        .map("close", "_close")
+                        .map("getcwd", "_getcwd")
+                        .map("unlink", "_unlink")
+                        .map("access", "_access")
+                        .map("open", "_open")
+                        .map("dup", "_dup")
+                        .map("dup2", "_dup2")
+                        .map("lseek", "_lseek")
+                        .map("ftruncate", "_chsize")
+                        .build();
+            
+            case SOLARIS:
+                return Platform.IS_32_BIT 
+                    ? new SimpleFunctionMapper.Builder()
+                        .map("stat", "stat64")
+                        .map("fstat", "fstat64")
+                        .map("lstat", "lstat64")
+                        .build()
+                    : null;
+            default:
+                return null;
+        }
+    }
+    
+    private static Map<LibraryOption, Object> options() {
+        Map<LibraryOption, Object> options = new HashMap<LibraryOption, Object>();
+        
+        FunctionMapper functionMapper = functionMapper();
+        if (functionMapper != null) {
+            options.put(LibraryOption.FunctionMapper, functionMapper);
+        }
+
+        options.put(LibraryOption.TypeMapper, POSIXTypeMapper.INSTANCE);
+        options.put(LibraryOption.LoadNow, Boolean.TRUE);
+        
+        return Collections.unmodifiableMap(options);
+    }
+
+    private static final class DefaultLibCProvider implements LibCProvider {
+        public static final LibCProvider INSTANCE = new DefaultLibCProvider();
+
+        private static final class SingletonHolder {
+            public static LibC libc;
+            public static Crypt crypt;
+            static {
+                LibraryLoader<? extends LibC> libcLoader = LibraryLoader.create(libraryInterface());
+
+                // always do a default search
+                libcLoader.searchDefault();
+
+                for (String library : libraries()) {
+                    libcLoader.library(library);
+                }
+
+                for (Map.Entry<LibraryOption, Object> entry : options().entrySet()) {
+                    libcLoader.option(entry.getKey(), entry.getValue());
+                }
+
+                libcLoader.failImmediately();
+
+                libc = libcLoader.load();
+
+                Crypt c = null;
+
+                // FIXME: This is kinda gross but there's no way to tell jnr-ffi that some libraries are ok to fail
+                // See jruby/jruby#5447.
+                try {
+                    LibraryLoader<Crypt> loader = LibraryLoader.create(Crypt.class).failImmediately();
+                    c = loader.load("libcrypt.so.1");
+                } catch (UnsatisfiedLinkError ule) {
+                    try {
+                        LibraryLoader<Crypt> loader = LibraryLoader.create(Crypt.class).failImmediately();
+                        c = loader.load("crypt");
+                    } catch (UnsatisfiedLinkError ule2) {
+                        try {
+                            LibraryLoader<Crypt> loader = LibraryLoader.create(Crypt.class).failImmediately();
+                            c = loader.load(STANDARD_C_LIBRARY_NAME);
+                        } catch (UnsatisfiedLinkError ule3) {
+                            // TODO: log somewhere? Warning?
+                        }
+                    }
+                }
+
+                crypt = c;
+            }
+        }
+
+        public final LibC getLibC() {
+            return SingletonHolder.libc;
+        }
+
+        public final Crypt getCrypt() {
+            return SingletonHolder.crypt;
+        }
+    }
+}
diff --git a/src/main/java/jnr/posix/POSIXFunctionMapper.java b/src/main/java/jnr/posix/POSIXFunctionMapper.java
new file mode 100644
index 0000000..94d30bf
--- /dev/null
+++ b/src/main/java/jnr/posix/POSIXFunctionMapper.java
@@ -0,0 +1,28 @@
+
+package jnr.posix;
+
+import jnr.ffi.mapper.FunctionMapper;
+
+/**
+ * No longer used.  It used to map function names from libc names to
+ * msvcrt names.
+ *
+ * @deprecated Use SimpleFunctionMapper instead.
+ */
+@Deprecated
+final class POSIXFunctionMapper implements FunctionMapper {
+    public static final FunctionMapper INSTANCE = new POSIXFunctionMapper();
+
+    private POSIXFunctionMapper() {}
+  
+    public String mapFunctionName(String name, Context ctx) {
+        if (ctx.getLibrary().getName().equals("msvcrt")) {
+            // FIXME: We should either always _ name for msvcrt or get good list of _ methods
+            if (name.equals("getpid") || name.equals("chmod")) {
+                name = "_" + name;
+            }
+        }
+        return name;
+    }
+
+}
diff --git a/src/main/java/jnr/posix/POSIXHandler.java b/src/main/java/jnr/posix/POSIXHandler.java
new file mode 100644
index 0000000..46fb4c0
--- /dev/null
+++ b/src/main/java/jnr/posix/POSIXHandler.java
@@ -0,0 +1,81 @@
+package jnr.posix;
+
+import jnr.constants.platform.Errno;
+
+import java.io.File;
+import java.io.InputStream;
+import java.io.PrintStream;
+
+/**
+ * The POSIXHandler class allows you do implement the runtime-specific behavior you need in
+ * such a way that it is insulated from the implementation of the POSIX library.  Implementing
+ * each of the methods in this interface should give you are working POSIX implementation. 
+ *
+ */
+public interface POSIXHandler {
+    public enum WARNING_ID {
+        DUMMY_VALUE_USED("DUMMY_VALUE_USED");
+        
+        private String messageID;
+
+        WARNING_ID(String messageID) {
+            this.messageID = messageID;
+        }
+    }
+    public void error(Errno error, String extraData);
+    public void error(Errno error, String methodName, String extraData);
+    
+    /**
+     * Specify that posix method is unimplemented.  In JRuby we generate an
+     * exception with this.
+     *
+     * @param methodName the POSIX method that failed
+     */
+    public void unimplementedError(String methodName);
+    
+    public void warn(WARNING_ID id, String message, Object... data);
+    
+    /**
+     * @return should we provide verbose output about POSIX activities
+     */
+    public boolean isVerbose();
+
+    /**
+     * @return current working directory of your runtime.
+     */
+    public File getCurrentWorkingDirectory();
+    
+    /**
+     * @return current set of environment variables of your runtime.
+     */
+    public String[] getEnv();
+    
+    /**
+     * @return your runtime's current input stream
+     */
+    public InputStream getInputStream();
+    
+    /**
+     * @return your runtime's current output stream
+     */
+    public PrintStream getOutputStream();
+    
+    /**
+     * Get your runtime's process ID.  This is only intended for non-native POSIX support (e.g.
+     * environments where JNA cannot load or security restricted environments).  In JRuby we
+     * found a number of packages which would rather have some identity for the runtime than
+     * nothing.
+     * 
+     * Note: If you do not want this to work you impl can just call {@link #unimplementedError(String)}.
+     *
+     * @return your runtime's process ID
+     */
+    public int getPID();
+    
+    /**
+     * Get your runtime's current ErrorStream
+     *
+     * @return your runtime's current error stream
+     */
+    public PrintStream getErrorStream();
+}
diff --git a/src/main/java/jnr/posix/POSIXTypeMapper.java b/src/main/java/jnr/posix/POSIXTypeMapper.java
new file mode 100644
index 0000000..da76d08
--- /dev/null
+++ b/src/main/java/jnr/posix/POSIXTypeMapper.java
@@ -0,0 +1,72 @@
+package jnr.posix;
+
+
+import jnr.constants.Constant;
+import jnr.ffi.mapper.*;
+import jnr.posix.util.Platform;
+
+final class POSIXTypeMapper implements TypeMapper {
+    public static final TypeMapper INSTANCE = new POSIXTypeMapper();
+    
+    private POSIXTypeMapper() {}
+    
+    public FromNativeConverter getFromNativeConverter(Class klazz) {
+        if (Passwd.class.isAssignableFrom(klazz)) {
+            if (Platform.IS_MAC) {
+                return MacOSPOSIX.PASSWD;
+            } else if (Platform.IS_LINUX) {
+                return LinuxPOSIX.PASSWD;
+            } else if (Platform.IS_SOLARIS) {
+                return SolarisPOSIX.PASSWD;
+            } else if (Platform.IS_FREEBSD) {
+                return FreeBSDPOSIX.PASSWD;
+            } else if (Platform.IS_DRAGONFLY) {
+                return DragonFlyPOSIX.PASSWD;
+            } else if (Platform.IS_OPENBSD) {
+                return OpenBSDPOSIX.PASSWD;
+            } else if (Platform.IS_WINDOWS) {
+                return WindowsPOSIX.PASSWD;
+            } else if (jnr.ffi.Platform.getNativePlatform().getOS().equals(jnr.ffi.Platform.OS.AIX)) {
+                return AixPOSIX.PASSWD;
+            }
+            return null;
+        } else if (Group.class.isAssignableFrom(klazz)) {
+            return BaseNativePOSIX.GROUP;
+
+        } else if (HANDLE.class.isAssignableFrom(klazz)) {
+            return HANDLE.Converter;
+        }
+        
+        return null;
+    }
+    
+    public ToNativeConverter getToNativeConverter(Class klazz) {
+        if (FileStat.class.isAssignableFrom(klazz)) {
+            return BaseNativePOSIX.FileStatConverter;
+
+        } else if (NativeTimes.class.isAssignableFrom(klazz)) {
+            return BaseNativePOSIX.TimesConverter;
+
+        } else if (Constant.class.isAssignableFrom(klazz)) {
+            return BaseNativePOSIX.ConstantConverter;
+
+        } else if (WString.class.isAssignableFrom(klazz)) {
+            return WString.Converter;
+
+        } else if (HANDLE.class.isAssignableFrom(klazz)) {
+            return HANDLE.Converter;
+        } else if (MsgHdr.class.isAssignableFrom(klazz)) {
+            return BaseNativePOSIX.MsgHdrConverter;
+        }
+
+        return null;
+    }
+
+    public final ToNativeConverter getToNativeConverter(Class klazz, ToNativeContext context) {
+        return getToNativeConverter(klazz);
+    }
+
+    public final FromNativeConverter getFromNativeConverter(Class klazz, FromNativeContext context) {
+        return getFromNativeConverter(klazz);
+    }
+}
diff --git a/src/main/java/jnr/posix/Passwd.java b/src/main/java/jnr/posix/Passwd.java
new file mode 100644
index 0000000..63cff5f
--- /dev/null
+++ b/src/main/java/jnr/posix/Passwd.java
@@ -0,0 +1,14 @@
+package jnr.posix;
+
+public interface Passwd {
+    public String getLoginName();
+    public String getPassword();
+    public long getUID();
+    public long getGID();
+    public int getPasswdChangeTime();
+    public String getAccessClass();
+    public String getGECOS();
+    public String getHome();
+    public String getShell();
+    public int getExpire();
+}
diff --git a/src/main/java/jnr/posix/RLimit.java b/src/main/java/jnr/posix/RLimit.java
new file mode 100644
index 0000000..0a0018c
--- /dev/null
+++ b/src/main/java/jnr/posix/RLimit.java
@@ -0,0 +1,13 @@
+package jnr.posix;
+
+import jnr.ffi.*;
+
+public abstract class RLimit extends Struct {
+    protected RLimit(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+
+    public abstract void init(long current, long max);
+    public abstract long rlimCur();
+    public abstract long rlimMax();
+}
diff --git a/src/main/java/jnr/posix/SignalHandler.java b/src/main/java/jnr/posix/SignalHandler.java
new file mode 100644
index 0000000..33ab5de
--- /dev/null
+++ b/src/main/java/jnr/posix/SignalHandler.java
@@ -0,0 +1,5 @@
+package jnr.posix;
+
+public interface SignalHandler {
+    public void handle(int signal);
+}
diff --git a/src/main/java/jnr/posix/SimpleFunctionMapper.java b/src/main/java/jnr/posix/SimpleFunctionMapper.java
new file mode 100644
index 0000000..6894d5d
--- /dev/null
+++ b/src/main/java/jnr/posix/SimpleFunctionMapper.java
@@ -0,0 +1,31 @@
+package jnr.posix;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class SimpleFunctionMapper implements jnr.ffi.mapper.FunctionMapper {
+    private final Map<String, String> functionNameMap;
+    
+    private SimpleFunctionMapper(Map<String, String> map) {
+        functionNameMap = Collections.unmodifiableMap(new HashMap<String, String>(map));
+    }
+    
+    public String mapFunctionName(String functionName, Context context) {
+        String nativeFunction = functionNameMap.get(functionName);
+        return nativeFunction != null ? nativeFunction : functionName;
+    }
+    
+    public static class Builder {
+        private final Map<String, String> functionNameMap = Collections.synchronizedMap(new HashMap<String, String>());
+
+        public Builder map(String posixName, String nativeFunction) {
+            functionNameMap.put(posixName, nativeFunction);
+            return this;
+        }
+        
+        public SimpleFunctionMapper build() {
+            return new SimpleFunctionMapper(functionNameMap);        
+        }
+    } 
+}
diff --git a/src/main/java/jnr/posix/SocketMacros.java b/src/main/java/jnr/posix/SocketMacros.java
new file mode 100644
index 0000000..10de54a
--- /dev/null
+++ b/src/main/java/jnr/posix/SocketMacros.java
@@ -0,0 +1,12 @@
+package jnr.posix;
+
+import jnr.ffi.Pointer;
+
+/**
+ * @author Bob McWhirter
+ */
+public interface SocketMacros {
+    public int CMSG_SPACE(int l);
+    public int CMSG_LEN(int l);
+    public Pointer CMSG_DATA(Pointer cmsg);
+}
diff --git a/src/main/java/jnr/posix/SolarisFileStat32.java b/src/main/java/jnr/posix/SolarisFileStat32.java
new file mode 100644
index 0000000..ce22476
--- /dev/null
+++ b/src/main/java/jnr/posix/SolarisFileStat32.java
@@ -0,0 +1,107 @@
+
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+
+public class SolarisFileStat32 extends BaseFileStat implements NanosecondFileStat {
+    static final class Layout extends StructLayout {
+
+        Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+        public static final int _ST_FSTYPSZ = 16;		/* array size for file system type name */
+
+        public final Signed32 st_dev = new Signed32();
+        public final SignedLong[] st_pad1 = array(new SignedLong[3]);
+        public final Signed64 st_ino = new Signed64();
+        public final Signed32 st_mode = new Signed32();
+        public final Signed32 st_nlink = new Signed32();
+        public final Signed32 st_uid = new Signed32();
+        public final Signed32 st_gid = new Signed32();
+        public final Signed32 st_rdev = new Signed32();
+        public final SignedLong[] st_pad2 = array(new SignedLong[2]);
+        public final Signed64 st_size = new Signed64();
+        public final Signed32 st_atim_sec = new Signed32();
+        public final Signed32 st_atim_nsec = new Signed32();
+        public final Signed32 st_mtim_sec = new Signed32();
+        public final Signed32 st_mtim_nsec = new Signed32();
+        public final Signed32 st_ctim_sec = new Signed32();
+        public final Signed32 st_ctim_nsec = new Signed32();
+        public final Signed32 st_blksize = new Signed32();
+        public final Signed64 st_blocks = new Signed64();
+        public final Signed8[] st_fstype = array(new Signed8[_ST_FSTYPSZ]);
+        public final SignedLong[] st_pad4 = array(new SignedLong[8]);
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public SolarisFileStat32(NativePOSIX posix) {
+        super(posix, layout);
+    }
+    
+    public long atime() {
+        return layout.st_atim_sec.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctim_sec.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return layout.st_mode.get(memory) & 0xffff;
+    }
+
+    public long mtime() {
+        return layout.st_mtim_sec.get(memory);
+    }
+
+    public int nlink() {
+        return layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout.st_size.get(memory);
+    }
+
+    public int uid() {
+        return layout.st_uid.get(memory);
+    }
+
+    @Override
+    public long aTimeNanoSecs() {
+        return layout.st_atim_nsec.get(memory);
+    }
+
+    @Override
+    public long cTimeNanoSecs() {
+        return layout.st_ctim_nsec.get(memory);
+    }
+
+    @Override
+    public long mTimeNanoSecs() {
+        return layout.st_mtim_nsec.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/SolarisFileStat64.java b/src/main/java/jnr/posix/SolarisFileStat64.java
new file mode 100644
index 0000000..a965451
--- /dev/null
+++ b/src/main/java/jnr/posix/SolarisFileStat64.java
@@ -0,0 +1,108 @@
+
+package jnr.posix;
+
+
+import jnr.ffi.*;
+
+public class SolarisFileStat64 extends BaseFileStat implements NanosecondFileStat {
+    static final class Layout extends StructLayout {
+
+        Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public static final int _ST_FSTYPSZ = 16;		/* array size for file system type name */
+        public final UnsignedLong st_dev = new UnsignedLong();
+        public final Signed64 st_ino = new Signed64();
+        public final Signed32 st_mode = new Signed32();
+        public final Signed32 st_nlink = new Signed32();
+        public final Signed32 st_uid = new Signed32();
+        public final Signed32 st_gid = new Signed32();
+        public final UnsignedLong st_rdev = new UnsignedLong();
+        public final Signed64 st_size = new Signed64();
+        public final SignedLong st_atim_sec = new SignedLong();
+        public final SignedLong st_atim_nsec = new SignedLong();
+        public final SignedLong st_mtim_sec = new SignedLong();
+        public final SignedLong st_mtim_nsec = new SignedLong();
+        public final SignedLong st_ctim_sec = new SignedLong();
+        public final SignedLong st_ctim_nsec = new SignedLong();
+        public final Signed32 st_blksize = new Signed32();
+        public final Signed64 st_blocks = new Signed64();
+        public final Signed8[] st_fstype = array(new Signed8[_ST_FSTYPSZ]);
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public SolarisFileStat64() {
+        this(null);
+    }
+    public SolarisFileStat64(NativePOSIX posix) {
+        super(posix, layout);
+    }
+
+    public long atime() {
+        return layout.st_atim_sec.get(memory);
+    }
+
+    public long blocks() {
+        return layout.st_blocks.get(memory);
+    }
+
+    public long blockSize() {
+        return layout.st_blksize.get(memory);
+    }
+
+    public long ctime() {
+        return layout.st_ctim_sec.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return layout.st_mode.get(memory) & 0xffff;
+    }
+
+    public long mtime() {
+        return layout.st_mtim_sec.get(memory);
+    }
+
+    public int nlink() {
+        return layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout.st_size.get(memory);
+    }
+
+    public int uid() {
+        return layout.st_uid.get(memory);
+    }
+
+    @Override
+    public long aTimeNanoSecs() {
+        return layout.st_atim_nsec.get(memory);
+    }
+
+    @Override
+    public long cTimeNanoSecs() {
+        return layout.st_ctim_nsec.get(memory);
+    }
+
+    @Override
+    public long mTimeNanoSecs() {
+        return layout.st_mtim_nsec.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/SolarisLibC.java b/src/main/java/jnr/posix/SolarisLibC.java
new file mode 100644
index 0000000..7efd010
--- /dev/null
+++ b/src/main/java/jnr/posix/SolarisLibC.java
@@ -0,0 +1,4 @@
+package jnr.posix;
+
+public interface SolarisLibC extends UnixLibC {
+}
diff --git a/src/main/java/jnr/posix/SolarisPOSIX.java b/src/main/java/jnr/posix/SolarisPOSIX.java
new file mode 100644
index 0000000..46c7367
--- /dev/null
+++ b/src/main/java/jnr/posix/SolarisPOSIX.java
@@ -0,0 +1,110 @@
+package jnr.posix;
+
+import java.nio.ByteBuffer;
+import jnr.constants.platform.Confstr;
+import jnr.constants.platform.Fcntl;
+import jnr.constants.platform.Sysconf;
+import jnr.ffi.*;
+import jnr.ffi.mapper.FromNativeContext;
+import jnr.posix.util.MethodName;
+import jnr.posix.util.Platform;
+
+import static jnr.constants.platform.Errno.EINVAL;
+import jnr.constants.platform.Pathconf;
+
+final class SolarisPOSIX extends BaseNativePOSIX {
+    SolarisPOSIX(LibCProvider libc, POSIXHandler handler) {
+        super(libc, handler);
+    }
+    
+    public FileStat allocateStat() {
+        return Platform.IS_32_BIT ? new SolarisFileStat32(this) : new SolarisFileStat64(this);
+    }
+
+    public MsgHdr allocateMsgHdr() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return null;
+    }
+
+    public SocketMacros socketMacros() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return null;
+    }
+
+    public long sysconf(Sysconf name) {
+        return libc().sysconf(name);
+    }
+
+    public int confstr(Confstr name, ByteBuffer buf, int len) {
+        return libc().confstr(name, buf, len);
+    }
+
+    public int fpathconf(int fd, Pathconf name) {
+        return libc().fpathconf(fd, name);
+    }
+
+    public Times times() {
+        return NativeTimes.times(this);
+    }
+
+    public static final int LOCK_SH = 1;
+    public static final int LOCK_EX = 2;
+    public static final int LOCK_NB = 4;
+    public static final int LOCK_UN = 8;
+
+    public static final int SEEK_SET = 0;
+
+    public static class Layout extends StructLayout {
+        protected Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final int16_t l_type = new int16_t(); // short
+        public final int16_t l_whence = new int16_t(); // short
+        public final off_t l_start = new off_t();
+        public final off_t l_len = new off_t();
+        public final int32_t l_sysid = new int32_t(); // int
+        public final pid_t l_pid = new pid_t();
+        public final int32_t[] l_pad = new int32_t[4]; // int[4]
+    }
+
+    private static final Layout FLOCK_LAYOUT = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public int flock(int fd, int operation) {
+        Pointer lock = getRuntime().getMemoryManager().allocateTemporary(FLOCK_LAYOUT.size(), true);
+
+        switch (operation & ~LOCK_NB) {
+            case LOCK_SH:
+                FLOCK_LAYOUT.l_type.set(lock, (short) Fcntl.F_RDLCK.intValue());
+                break;
+            case LOCK_EX:
+                FLOCK_LAYOUT.l_type.set(lock, (short) Fcntl.F_WRLCK.intValue());
+                break;
+            case LOCK_UN:
+                FLOCK_LAYOUT.l_type.set(lock, (short) Fcntl.F_UNLCK.intValue());
+                break;
+            default:
+                errno(EINVAL.intValue());
+                return -1;
+        }
+        FLOCK_LAYOUT.l_whence.set(lock, (short) SEEK_SET);
+        FLOCK_LAYOUT.l_start.set(lock, 0);
+        FLOCK_LAYOUT.l_len.set(lock, 0);
+
+        return libc().fcntl(fd, (operation & LOCK_NB) != 0 ? Fcntl.F_SETLK.intValue() : Fcntl.F_SETLKW.intValue(), lock);
+    }
+
+    public static final PointerConverter PASSWD = new PointerConverter() {
+        public Object fromNative(Object arg, FromNativeContext ctx) {
+            return arg != null ? new SolarisPasswd((Pointer) arg) : null;
+        }
+    };
+
+    public Pointer allocatePosixSpawnFileActions() {
+        return Memory.allocateDirect(getRuntime(), 8);
+    }
+
+    public Pointer allocatePosixSpawnattr() {
+        return Memory.allocateDirect(getRuntime(), 8);
+    }
+}
diff --git a/src/main/java/jnr/posix/SolarisPasswd.java b/src/main/java/jnr/posix/SolarisPasswd.java
new file mode 100644
index 0000000..e2c8337
--- /dev/null
+++ b/src/main/java/jnr/posix/SolarisPasswd.java
@@ -0,0 +1,59 @@
+
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+
+public class SolarisPasswd extends NativePasswd implements Passwd {
+    static final class Layout extends StructLayout {
+
+        private Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final UTF8StringRef pw_name = new UTF8StringRef();   // user name
+        public final UTF8StringRef pw_passwd = new UTF8StringRef(); // password (encrypted)
+        public final Signed32 pw_uid = new Signed32();       // user id
+        public final Signed32 pw_gid = new Signed32();       // user id
+        public final Pointer pw_age = new Pointer();   // unused
+        public final Pointer pw_comment = new Pointer();// unused
+        public final UTF8StringRef pw_gecos = new UTF8StringRef();  // login info
+        public final UTF8StringRef pw_dir = new UTF8StringRef();    // home directory
+        public final UTF8StringRef pw_shell = new UTF8StringRef();  // default shell
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public SolarisPasswd(jnr.ffi.Pointer memory) {
+        super(memory);
+    }
+    
+    public java.lang.String getAccessClass() {
+        return "unknown";
+    }
+    public java.lang.String getGECOS() {
+        return layout.pw_gecos.get(memory);
+    }
+    public long getGID() {
+        return layout.pw_gid.get(memory);
+    }
+    public java.lang.String getHome() {
+        return layout.pw_dir.get(memory);
+    }
+    public java.lang.String getLoginName() {
+        return layout.pw_name.get(memory);
+    }
+    public int getPasswdChangeTime() {
+        return 0;
+    }
+    public java.lang.String getPassword() {
+        return layout.pw_passwd.get(memory);
+    }
+    public java.lang.String getShell() {
+        return layout.pw_shell.get(memory);
+    }
+    public long getUID() {
+        return layout.pw_uid.get(memory);
+    }
+    public int getExpire() {
+        return Integer.MAX_VALUE;
+    }
+}
diff --git a/src/main/java/jnr/posix/SpawnAttribute.java b/src/main/java/jnr/posix/SpawnAttribute.java
new file mode 100644
index 0000000..e9fb913
--- /dev/null
+++ b/src/main/java/jnr/posix/SpawnAttribute.java
@@ -0,0 +1,99 @@
+package jnr.posix;
+
+import jnr.ffi.*;
+import jnr.ffi.byref.NumberByReference;
+
+public abstract class SpawnAttribute {
+    public static final int RESETIDS   = 0x0001;  /* [SPN] R[UG]ID not E[UG]ID */
+    public static final int SETPGROUP  = 0x0002;  /* [SPN] set non-parent PGID */
+    public static final int SETSIGDEF  = 0x0004;  /* [SPN] reset sigset default */
+    public static final int SETSIGMASK = 0x0008;  /* [SPN] set signal mask */
+    
+    abstract boolean set(POSIX posix, Pointer nativeFileActions);
+
+    public static SpawnAttribute pgroup(long pgroup) {
+        return new PGroup(pgroup);
+    }
+
+    public static SpawnAttribute flags(short flags) {
+        return new SetFlags(flags);
+    }
+
+    public static SpawnAttribute sigdef(long sigdef) {
+        throw new RuntimeException("sigdefault not yet supported");
+//        return new Sigdef(sigdef);
+    }
+
+    public static SpawnAttribute sigmask(long sigmask) {
+        throw new RuntimeException("sigmask not yet supported");
+//        return new Sigmask(sigmask);
+    }
+
+
+    private static final class PGroup extends SpawnAttribute {
+        final long pgroup;
+
+        public PGroup(long pgroup) {
+            this.pgroup = pgroup;
+        }
+
+        final boolean set(POSIX posix, Pointer nativeSpawnAttr) {
+            return ((UnixLibC) posix.libc()).posix_spawnattr_setpgroup(nativeSpawnAttr, pgroup) == 0;
+        }
+
+        public String toString() {
+            return "SpawnAttribute::PGroup(pgroup = " + pgroup + ")";
+        }
+    }
+
+    private static final class SetFlags extends SpawnAttribute {
+        final short flags;
+
+        public SetFlags(short flags) {
+            this.flags = flags;
+        }
+
+        final boolean set(POSIX posix, Pointer nativeSpawnAttr) {
+            return ((UnixLibC) posix.libc()).posix_spawnattr_setflags(nativeSpawnAttr, flags) == 0;
+        }
+
+        public String toString() {
+            return "SpawnAttribute::SetFlags(flags = " + Integer.toHexString(flags) + ")";
+        }
+    }
+
+    private static final class Sigmask extends SpawnAttribute {
+        final long sigmask;
+
+        public Sigmask(long sigmask) {
+            this.sigmask = sigmask;
+        }
+
+        final boolean set(POSIX posix, Pointer nativeSpawnAttr) {
+            throw new RuntimeException("sigmask not yet supported");
+//            return ((UnixLibC) posix.libc()).posix_spawnattr_setsigmask(nativeSpawnAttr, mask) == 0;
+        }
+
+        public String toString() {
+            return "SpawnAttribute::Sigmask(mask = " + Long.toHexString(sigmask) + ")";
+        }
+    }
+
+    private static final class Sigdef extends SpawnAttribute {
+        final long sigdef;
+
+        public Sigdef(long sigdef) {
+            this.sigdef = sigdef;
+        }
+
+        final boolean set(POSIX posix, Pointer nativeSpawnAttr) {
+            throw new RuntimeException("sigdefault not yet supported");
+//            return ((UnixLibC) posix.libc()).posix_spawnattr_setsigdefault(nativeSpawnAttr, sigdef) == 0;
+        }
+
+        public String toString() {
+            return "SpawnAttribute::Sigdef(def = " + Long.toHexString(sigdef) + ")";
+        }
+    }
+
+}
diff --git a/src/main/java/jnr/posix/SpawnFileAction.java b/src/main/java/jnr/posix/SpawnFileAction.java
new file mode 100644
index 0000000..1657b3f
--- /dev/null
+++ b/src/main/java/jnr/posix/SpawnFileAction.java
@@ -0,0 +1,106 @@
+package jnr.posix;
+
+import jnr.ffi.Pointer;
+
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetEncoder;
+
+public abstract class SpawnFileAction {
+    abstract boolean act(POSIX posix, Pointer nativeFileActions);
+
+    public static SpawnFileAction dup(int fd, int newfd) {
+        return new Dup(fd, newfd);
+    }
+
+    public static SpawnFileAction open(String path, int fd, int flags, int mode) {
+        return new Open(path, fd, flags, mode);
+    }
+
+    public static SpawnFileAction close(int fd) {
+        return new Close(fd);
+    }
+
+    private static final class Dup extends SpawnFileAction {
+        final int fd, newfd;
+
+        public Dup(int fd, int newfd) {
+            this.fd = fd;
+            this.newfd = newfd;
+        }
+
+        final boolean act(POSIX posix, Pointer nativeFileActions) {
+            return ((UnixLibC) posix.libc()).posix_spawn_file_actions_adddup2(nativeFileActions, fd, newfd) == 0;
+        }
+
+        public String toString() {
+            return "SpawnFileAction::Dup(old = " + fd + ", new = " + newfd + ")";
+        }
+    }
+
+    private static final class Open extends SpawnFileAction {
+        final String path;
+        final int fd;
+        final int flags, mode;
+        final ByteBuffer nativePath;
+
+        public Open(String path, int fd, int flags, int mode) {
+            this.path = path;
+            this.fd = fd;
+            this.flags = flags;
+            this.mode = mode;
+            this.nativePath = defensiveCopy(path);
+        }
+
+        private ByteBuffer defensiveCopy(String path) {
+            /*
+            This logic allocates a direct ByteBuffer to use for the path in order to work around systems that have not
+            patched CVE-2014-4043, in which older glibc versions do not make a defensive copy of the file path passed to
+            posix_spawn_file_actions_addopen. The buffer may be freed by the caller before it can be used in an
+            eventual posix_spawn call.
+
+            See https://bugzilla.redhat.com/show_bug.cgi?id=1983750 for a RHEL version of this issue.
+            */
+
+            // determine encoded byte array length
+            CharsetEncoder encoder = Charset.defaultCharset().newEncoder();
+            int bpc = (int) encoder.maxBytesPerChar();
+            int size = (path.length() + 1) * bpc;
+
+            // transcode to native buffer
+            ByteBuffer nativePath = ByteBuffer.allocateDirect(size);
+            encoder.encode(CharBuffer.wrap(path), nativePath, true);
+            nativePath.flip();
+
+            // null terminate
+            nativePath.limit(nativePath.limit() + bpc);
+
+            return nativePath;
+        }
+
+        final boolean act(POSIX posix, Pointer nativeFileActions) {
+            return ((UnixLibC) posix.libc()).posix_spawn_file_actions_addopen(nativeFileActions, fd, nativePath, flags, mode) == 0;
+        }
+
+        public String toString() {
+            return "SpawnFileAction::Open(path = '" + path + "', fd = " + fd + ", flags = " + Integer.toHexString(flags) + ", mode = " + Integer.toHexString(mode) + ")";
+        }
+    }
+
+    private static final class Close extends SpawnFileAction {
+        final int fd;
+
+        public Close(int fd) {
+            this.fd = fd;
+        }
+
+        final boolean act(POSIX posix, Pointer nativeFileActions) {
+            return ((UnixLibC) posix.libc()).posix_spawn_file_actions_addclose(nativeFileActions, fd) == 0;
+        }
+
+        public String toString() {
+            return "SpawnFileAction::Close(fd = " + fd + ")";
+        }
+    }
+}
diff --git a/src/main/java/jnr/posix/Times.java b/src/main/java/jnr/posix/Times.java
new file mode 100644
index 0000000..ed34fce
--- /dev/null
+++ b/src/main/java/jnr/posix/Times.java
@@ -0,0 +1,9 @@
+package jnr.posix;
+
+
+public interface Times {
+    public abstract long utime();
+    public abstract long stime();
+    public abstract long cutime();
+    public abstract long cstime();
+}
diff --git a/src/main/java/jnr/posix/Timespec.java b/src/main/java/jnr/posix/Timespec.java
new file mode 100644
index 0000000..a092070
--- /dev/null
+++ b/src/main/java/jnr/posix/Timespec.java
@@ -0,0 +1,14 @@
+package jnr.posix;
+
+import jnr.ffi.Struct;
+
+abstract public class Timespec extends Struct {
+    public Timespec(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+    abstract public void setTime(long[] timespec);
+    public abstract void sec(long sec);
+    public abstract void nsec(long nsec);
+    public abstract long sec();
+    public abstract long nsec();
+}
diff --git a/src/main/java/jnr/posix/Timeval.java b/src/main/java/jnr/posix/Timeval.java
new file mode 100644
index 0000000..e5942e4
--- /dev/null
+++ b/src/main/java/jnr/posix/Timeval.java
@@ -0,0 +1,14 @@
+package jnr.posix;
+
+import jnr.ffi.Struct;
+
+abstract public class Timeval extends Struct {
+    public Timeval(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+    abstract public void setTime(long[] timeval);
+    public abstract void sec(long sec);
+    public abstract void usec(long usec);
+    public abstract long sec();
+    public abstract long usec();
+}
diff --git a/src/main/java/jnr/posix/UTimBuf64.java b/src/main/java/jnr/posix/UTimBuf64.java
new file mode 100644
index 0000000..f836e4e
--- /dev/null
+++ b/src/main/java/jnr/posix/UTimBuf64.java
@@ -0,0 +1,14 @@
+package jnr.posix;
+
+import jnr.ffi.Struct;
+
+public final class UTimBuf64 extends Struct {
+    public final Signed64 actime = new Signed64();
+    public final Signed64 modtime = new Signed64();
+
+    public UTimBuf64(jnr.ffi.Runtime runtime, long actime, long modtime) {
+        super(runtime);
+        this.actime.set(actime);
+        this.modtime.set(modtime);
+    }
+}
diff --git a/src/main/java/jnr/posix/UnixLibC.java b/src/main/java/jnr/posix/UnixLibC.java
new file mode 100644
index 0000000..89666be
--- /dev/null
+++ b/src/main/java/jnr/posix/UnixLibC.java
@@ -0,0 +1,48 @@
+package jnr.posix;
+
+import jnr.ffi.Pointer;
+import jnr.ffi.annotations.Direct;
+import jnr.ffi.annotations.In;
+import jnr.ffi.annotations.Out;
+import jnr.ffi.byref.ByReference;
+import jnr.ffi.byref.IntByReference;
+import jnr.ffi.byref.NumberByReference;
+import jnr.ffi.byref.ShortByReference;
+import jnr.ffi.types.pid_t;
+
+import java.nio.ByteBuffer;
+
+public interface UnixLibC extends LibC {
+    public int posix_spawn(@Out ByReference pid, @In CharSequence path, @In Pointer fileActions,
+                           @In Pointer attr, @In CharSequence[] argv, @In CharSequence[] envp);
+
+    public int posix_spawnp(@Out ByReference pid, @In CharSequence path, @In Pointer fileActions,
+                            @In Pointer attr, @In CharSequence[] argv, @In CharSequence[] envp);
+
+    public int posix_spawn_file_actions_init(Pointer fileActions);
+    public int posix_spawn_file_actions_destroy(Pointer fileActions);
+    public int posix_spawn_file_actions_addclose(Pointer fileActions, int filedes);
+
+    /**
+     * @deprecated due to CVE-2014-4043 (https://bugzilla.redhat.com/show_bug.cgi?id=1983750)
+     */
+    @Deprecated
+    public int posix_spawn_file_actions_addopen(Pointer fileActions, int filedes, CharSequence path,
+                                                int oflag, int mode);
+    public int posix_spawn_file_actions_addopen(Pointer fileActions, int filedes, @Direct ByteBuffer path,
+                                                int oflag, int mode);
+    public int posix_spawn_file_actions_adddup2(Pointer fileActions, int filedes, int newfiledes);
+    public int posix_spawnattr_init(Pointer attr);
+    public int posix_spawnattr_destroy(Pointer attr);
+    public int posix_spawnattr_setflags(Pointer attr, short flags);
+    public int posix_spawnattr_getflags(Pointer attr, ShortByReference flags);
+    public int posix_spawnattr_setpgroup(Pointer attr, @pid_t long pgroup);
+    public int posix_spawnattr_getpgroup(Pointer attr, NumberByReference pgroup);
+    public int posix_spawnattr_setsigmask(Pointer attr, Pointer sigmask);
+    public int posix_spawnattr_getsigmask(Pointer attr, Pointer sigmask);
+    public int posix_spawnattr_setsigdefault(Pointer attr, Pointer sigdefault);
+    public int posix_spawnattr_getsigdefault(Pointer attr, Pointer sigdefault);
+    public int sigprocmask(int how, Pointer set, Pointer get);
+
+    int mkfifo(CharSequence filename, int mode);
+}
diff --git a/src/main/java/jnr/posix/WString.java b/src/main/java/jnr/posix/WString.java
new file mode 100644
index 0000000..590a858
--- /dev/null
+++ b/src/main/java/jnr/posix/WString.java
@@ -0,0 +1,60 @@
+package jnr.posix;
+
+import jnr.ffi.Memory;
+import jnr.ffi.Pointer;
+import jnr.ffi.mapper.ToNativeContext;
+import jnr.ffi.mapper.ToNativeConverter;
+import jnr.posix.util.WindowsHelpers;
+
+public final class WString {
+    static final jnr.ffi.Runtime runtime = jnr.ffi.Runtime.getSystemRuntime();
+
+    private final byte[] bytes;
+
+    WString(String string) {
+        bytes = WindowsHelpers.toWString(string);
+    }
+
+    private WString(byte[] bytes) {
+        this.bytes = bytes;
+    }
+
+    public static WString path(String path) {
+        return new WString(path(path, false));
+    }
+
+    public static byte[] path(String path, boolean longPathExtensionNeeded) {
+        if (longPathExtensionNeeded && path.length() > 240) { // FIXME: This is not right value.  Needs tests around actual char boundary.
+            if (path.startsWith("//")) { // UNC Path
+                path = "//?/UNC/" + path.substring(2);
+            } else if (path.startsWith("\\\\")) {
+                path = "\\\\?\\UNC\\" + path.substring(2);
+            } else if (WindowsHelpers.isDriveLetterPath(path)) {
+                if (path.contains("/")) {
+                    path = "//?/" + path;
+                } else {
+                    path = "\\\\?\\" + path;
+                }
+            }
+        }
+
+        return WindowsHelpers.toWPath(path);
+    }
+
+    public static final ToNativeConverter<WString, Pointer> Converter = new ToNativeConverter<WString, Pointer>() {
+
+        public Pointer toNative(WString value, ToNativeContext context) {
+            if (value == null) {
+                return null;
+            }
+
+            Pointer memory = Memory.allocateDirect(runtime, value.bytes.length + 1, true);
+            memory.put(0, value.bytes, 0, value.bytes.length);
+            return memory;
+        }
+
+        public Class<Pointer> nativeType() {
+            return Pointer.class;
+        }
+    };
+}
diff --git a/src/main/java/jnr/posix/WindowsChildRecord.java b/src/main/java/jnr/posix/WindowsChildRecord.java
new file mode 100644
index 0000000..d4442e6
--- /dev/null
+++ b/src/main/java/jnr/posix/WindowsChildRecord.java
@@ -0,0 +1,28 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package jnr.posix;
+
+/**
+ *
+ * @author enebo
+ */
+public class WindowsChildRecord {
+    private final HANDLE process;
+    private final int pid;
+
+    public WindowsChildRecord(HANDLE process, int pid) {
+        this.process = process;
+        this.pid = pid;
+    }
+    
+    public HANDLE getProcess() {
+        return process;
+    }
+    
+    public int getPid() {
+        return pid;
+    }
+}
diff --git a/src/main/java/jnr/posix/WindowsFileStat.java b/src/main/java/jnr/posix/WindowsFileStat.java
new file mode 100644
index 0000000..96120e7
--- /dev/null
+++ b/src/main/java/jnr/posix/WindowsFileStat.java
@@ -0,0 +1,169 @@
+package jnr.posix;
+
+import jnr.ffi.StructLayout;
+
+// http://msdn.microsoft.com/en-us/library/14h5k7ff.aspx
+// This layout is meant to be used with stat64() family so _USE_32BIT_TIME_T is not in play.
+public class WindowsFileStat extends BaseFileStat {
+    private static final class Layout extends StructLayout {
+
+        private Layout(jnr.ffi.Runtime runtime) {
+            super(runtime);
+        }
+
+        public final Signed32 st_dev = new Signed32();
+        public final Signed16 st_ino = new Signed16();
+        public final Signed16 st_mode = new Signed16();
+        public final Signed16 st_nlink = new Signed16();
+        public final Signed16 st_uid = new Signed16();
+        public final Signed16 st_gid = new Signed16();
+        public final Signed32 st_rdev = new Signed32();
+        public final Signed64 st_size = new Signed64();
+        public final Signed64 st_atime = new Signed64();
+        public final Signed64 st_mtime = new Signed64();
+        public final Signed64 st_ctime = new Signed64();
+    }
+    private static final Layout layout = new Layout(jnr.ffi.Runtime.getSystemRuntime());
+
+    public WindowsFileStat(NativePOSIX posix) {
+        super(posix, layout);
+    }
+
+    public long atime() {
+        return layout.st_atime.get(memory);
+    }
+
+    public long blockSize() {
+        return 512;
+    }
+
+    public long blocks() {
+        return (layout.st_size.get(memory) + 512 - 1) / 512;
+    }
+
+    public long ctime() {
+        return layout.st_ctime.get(memory);
+    }
+
+    public long dev() {
+        return layout.st_dev.get(memory);
+    }
+
+    public int gid() {
+        return layout.st_gid.get(memory);
+    }
+
+    public long ino() {
+        return layout.st_ino.get(memory);
+    }
+
+    public int mode() {
+        return layout.st_mode.get(memory) & ~(S_IWGRP | S_IWOTH) & 0xffff;
+    }
+
+    public long mtime() {
+        return layout.st_mtime.get(memory);
+    }
+
+    public int nlink() {
+        return layout.st_nlink.get(memory);
+    }
+
+    public long rdev() {
+        return layout.st_rdev.get(memory);
+    }
+
+    public long st_size() {
+        return layout.st_size.get(memory);
+    }
+
+    public int uid() {
+        return layout.st_uid.get(memory);
+    }
+
+    // FIXME: Implement
+    @Override
+    public boolean groupMember(int gid) {
+        return true;
+    }
+
+    @Override
+    public boolean isExecutable() {
+        if (isOwned()) return (mode() & S_IXUSR) != 0;
+        if (isGroupOwned()) return (mode() & S_IXGRP) != 0;
+        if ((mode() & S_IXOTH) != 0) return false;
+
+        return true;
+    }
+
+    @Override
+    public boolean isExecutableReal() {
+        if (isROwned()) return (mode() & S_IXUSR) != 0;
+        if (groupMember(gid())) return (mode() & S_IXGRP) != 0;
+        if ((mode() & S_IXOTH) != 0) return false;
+
+        return true;
+    }
+
+    // FIXME: Implement
+    @Override
+    public boolean isOwned() {
+        return true;
+    }
+
+    // FIXME: Implement
+    @Override
+    public boolean isROwned() {
+        return true;
+    }
+    @Override
+    public boolean isReadable() {
+        if (isOwned()) return (mode() & S_IRUSR) != 0;
+        if (isGroupOwned()) return (mode() & S_IRGRP) != 0;
+        if ((mode() & S_IROTH) != 0) return false;
+
+        return true;
+    }
+
+    @Override
+    public boolean isReadableReal() {
+        if (isROwned()) return (mode() & S_IRUSR) != 0;
+        if (groupMember(gid())) return (mode() & S_IRGRP) != 0;
+        if ((mode() & S_IROTH) != 0) return false;
+
+        return true;
+    }
+
+    @Override
+    public boolean isWritable() {
+        if (isOwned()) return (mode() & S_IWUSR) != 0;
+        if (isGroupOwned()) return (mode() & S_IWGRP) != 0;
+        if ((mode() & S_IWOTH) != 0) return false;
+
+        return true;
+    }
+
+    @Override
+    public boolean isWritableReal() {
+        if (isROwned()) return (mode() & S_IWUSR) != 0;
+        if (groupMember(gid())) return (mode() & S_IWGRP) != 0;
+        if ((mode() & S_IWOTH) != 0) return false;
+
+        return true;
+    }
+
+    @Override
+    public java.lang.String toString() {
+        return "st_dev: " + layout.st_dev.get(memory) +
+                ", st_mode: " + Integer.toOctalString(mode()) +
+                ", layout.st_nlink: " + layout.st_nlink.get(memory) +
+                ", layout.st_rdev: " + layout.st_rdev.get(memory) +
+                ", layout.st_size: " + layout.st_size.get(memory) +
+                ", layout.st_uid: " + layout.st_uid.get(memory) +
+                ", layout.st_gid: " + layout.st_gid.get(memory) +
+                ", layout.st_atime: " + layout.st_atime.get(memory) +
+                ", layout.st_ctime: " + layout.st_ctime.get(memory) +
+                ", layout.st_mtime: " + layout.st_mtime.get(memory) +
+                ", layout.st_ino: " + layout.st_ino.get(memory);
+    }
+}
diff --git a/src/main/java/jnr/posix/WindowsLibC.java b/src/main/java/jnr/posix/WindowsLibC.java
new file mode 100644
index 0000000..495f399
--- /dev/null
+++ b/src/main/java/jnr/posix/WindowsLibC.java
@@ -0,0 +1,130 @@
+package jnr.posix;
+
+import jnr.ffi.Pointer;
+import jnr.ffi.Variable;
+import jnr.ffi.annotations.In;
+import jnr.ffi.annotations.Out;
+import jnr.ffi.annotations.StdCall;
+import jnr.ffi.annotations.Transient;
+import jnr.ffi.byref.IntByReference;
+
+import java.nio.ByteBuffer;
+import jnr.posix.windows.SystemTime;
+import jnr.posix.windows.WindowsByHandleFileInformation;
+import jnr.posix.windows.WindowsFileInformation;
+import jnr.posix.windows.WindowsFindData;
+
+public interface WindowsLibC extends LibC {
+    public static final int STD_INPUT_HANDLE = -10;
+    public static final int STD_OUTPUT_HANDLE = -11;
+    public static final int STD_ERROR_HANDLE = -12;
+
+    public static final int NORMAL_PRIORITY_CLASS = 0x00000020;
+    public static final int CREATE_UNICODE_ENVIRONMENT = 0x00000400;
+    
+    public static final int INFINITE = -1;
+
+    public static final int FILE_TYPE_DISK = 0x0001;
+    public static final int FILE_TYPE_CHAR = 0x0002;
+    public static final int FILE_TYPE_PIPE = 0x0003;
+    public static final int FILE_TYPE_REMOTE = 0x8000;
+    public static final int FILE_TYPE_UNKNOWN = 0x0000;
+
+    public static final int PROCESS_QUERY_INFORMATION = 0x0400;
+
+    public int _open_osfhandle(HANDLE handle, int flags);
+    public HANDLE _get_osfhandle(int fd);
+    public int _close(int fd);
+    public int _getpid();
+    int _stat64(CharSequence path, @Out @Transient FileStat stat);
+
+    int _umask(int mask);
+
+    public int _wmkdir(@In WString path);
+    public boolean RemoveDirectoryW(@In WString path);
+    public int _wchmod(@In WString path, int pmode);
+    public int _wchdir(@In WString path);
+    public int _wstat64(@In WString path, @Out @Transient FileStat stat);
+    public int _wstat64(@In byte[] path, @Out @Transient FileStat stat);
+    public int _pipe(int[] fds, int psize, int textmode);
+    
+    @StdCall
+    public boolean CreateProcessW(byte[] applicationName, 
+                                 @In @Out ByteBuffer buffer, 
+                                 WindowsSecurityAttributes processAttributes,
+                                 WindowsSecurityAttributes threadAttributes,
+                                 int inheritHandles,
+                                 int creationFlags,
+                                 @In Pointer envp,
+                                 @In byte[] currentDirectory,
+                                 WindowsStartupInfo startupInfo,
+                                 WindowsProcessInformation processInformation);
+
+    public HANDLE OpenProcess(@In int desiredAccess, @In int inheritHandle, @In int processId);
+
+    public int FileTimeToSystemTime(@In FileTime fileTime, @Out @Transient SystemTime systemTime);
+    public int GetFileAttributesW(@In WString path);
+    public int GetFileAttributesExW(@In WString path, @In int infoLevel, @Out @Transient WindowsFileInformation fileInformation);
+    public int GetFileAttributesExW(@In byte[] path, @In int infoLevel, @Out @Transient WindowsFileInformation fileInformation);
+    public int SetFileAttributesW(@In WString path, int flags);
+    public int GetFileInformationByHandle(@In HANDLE handle, @Out @Transient WindowsByHandleFileInformation fileInformation);
+
+    public int FindClose(HANDLE handle);
+    public HANDLE FindFirstFileW(@In WString wpath, @Out WindowsFindData findData);
+    public HANDLE FindFirstFileW(@In byte[] wpath, @Out WindowsFindData findData);
+    
+    @StdCall
+    public boolean GetExitCodeProcess(HANDLE handle, @Out Pointer exitCode);
+
+    @StdCall
+    public boolean GetExitCodeProcess(HANDLE handle, @Out IntByReference exitCode);
+
+    @StdCall
+    public int GetFileType(HANDLE handle);
+
+    @StdCall
+    public int GetFileSize(HANDLE handle, @Out IntByReference outSizeHigh);
+    
+    @StdCall
+    public HANDLE GetStdHandle(int stdHandle);
+
+    @StdCall
+    public boolean CreateHardLinkW(@In WString oldname, @In WString newName, @In WString reserved);
+
+    @StdCall
+    HANDLE CreateFileW(
+            byte[] lpFileName,
+            int dwDesiredAccess,
+            int dwShareMode,
+            Pointer lpSecurityAttributes,
+            int dwCreationDisposition,
+            int dwFlagsAndAttributes,
+            int hTemplateFile
+    );
+    
+    @StdCall
+    boolean SetEnvironmentVariableW(
+            @In WString envName,
+            @In WString envValue);
+
+    @StdCall
+    boolean GetComputerNameW(
+            @Out ByteBuffer lpBuffer,
+            IntByReference nSize);
+
+    @StdCall
+    boolean SetFileTime(
+            HANDLE  hFile,
+            FileTime lpCreationTime,
+            FileTime lpLastAccessTime,
+            FileTime lpLastWriteTime
+    );
+
+    @StdCall
+    boolean CloseHandle(HANDLE handle);
+    
+    @StdCall
+    int WaitForSingleObject(HANDLE handle, int milliseconds);
+
+    Variable<Long> _environ();
+}
diff --git a/src/main/java/jnr/posix/WindowsPOSIX.java b/src/main/java/jnr/posix/WindowsPOSIX.java
new file mode 100644
index 0000000..926a683
--- /dev/null
+++ b/src/main/java/jnr/posix/WindowsPOSIX.java
@@ -0,0 +1,921 @@
+package jnr.posix;
+
+import jnr.constants.platform.OpenFlags;
+import jnr.constants.platform.Fcntl;
+import jnr.constants.platform.Errno;
+import jnr.constants.platform.WaitFlags;
+import static jnr.constants.platform.Errno.*;
+import static jnr.constants.platform.windows.LastError.*;
+
+import jnr.ffi.LastError;
+import jnr.ffi.Pointer;
+import jnr.ffi.byref.IntByReference;
+import jnr.ffi.mapper.FromNativeContext;
+
+import java.io.FileDescriptor;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.util.HashMap;
+import java.util.Map;
+
+import jnr.posix.util.MethodName;
+import jnr.posix.util.Platform;
+import jnr.posix.util.WindowsHelpers;
+import jnr.posix.windows.CommonFileInformation;
+import jnr.posix.windows.WindowsByHandleFileInformation;
+import jnr.posix.windows.WindowsFileInformation;
+import jnr.posix.windows.WindowsFindData;
+
+final public class WindowsPOSIX extends BaseNativePOSIX {
+    private final static int FILE_TYPE_CHAR = 0x0002;
+
+    private final static Map<Integer, Errno> errorToErrnoMapper
+            = new HashMap<Integer, Errno>();
+
+    static {
+        errorToErrnoMapper.put(ERROR_INVALID_FUNCTION.value(), EINVAL);
+        errorToErrnoMapper.put(ERROR_FILE_NOT_FOUND.value(), ENOENT);
+        errorToErrnoMapper.put(ERROR_PATH_NOT_FOUND.value(), ENOENT);
+        errorToErrnoMapper.put(ERROR_TOO_MANY_OPEN_FILES.value(), EMFILE);
+        errorToErrnoMapper.put(ERROR_ACCESS_DENIED.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_INVALID_HANDLE.value(), EBADF );
+        errorToErrnoMapper.put(ERROR_ARENA_TRASHED.value(), ENOMEM);
+        errorToErrnoMapper.put(ERROR_NOT_ENOUGH_MEMORY.value(), ENOMEM);
+        errorToErrnoMapper.put(ERROR_INVALID_BLOCK.value(), ENOMEM);
+        errorToErrnoMapper.put(ERROR_BAD_ENVIRONMENT.value(), E2BIG );
+        errorToErrnoMapper.put(ERROR_BAD_FORMAT.value(), ENOEXEC);
+        errorToErrnoMapper.put(ERROR_INVALID_ACCESS.value(), EINVAL);
+        errorToErrnoMapper.put(ERROR_INVALID_DATA.value(), EINVAL);
+        errorToErrnoMapper.put(ERROR_INVALID_DRIVE.value(), ENOENT);
+        errorToErrnoMapper.put(ERROR_CURRENT_DIRECTORY.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_NOT_SAME_DEVICE.value(), EXDEV );
+        errorToErrnoMapper.put(ERROR_NO_MORE_FILES.value(), ENOENT);
+        errorToErrnoMapper.put(ERROR_WRITE_PROTECT.value(), EROFS );
+        errorToErrnoMapper.put(ERROR_BAD_UNIT.value(), ENODEV);
+        errorToErrnoMapper.put(ERROR_NOT_READY.value(), ENXIO );
+        errorToErrnoMapper.put(ERROR_BAD_COMMAND.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_CRC.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_BAD_LENGTH.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_SEEK.value(), EIO);
+        errorToErrnoMapper.put(ERROR_NOT_DOS_DISK.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_SECTOR_NOT_FOUND.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_OUT_OF_PAPER.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_WRITE_FAULT.value(), EIO);
+        errorToErrnoMapper.put(ERROR_READ_FAULT.value(), EIO);
+        errorToErrnoMapper.put(ERROR_GEN_FAILURE.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_LOCK_VIOLATION.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_SHARING_VIOLATION.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_WRONG_DISK.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_SHARING_BUFFER_EXCEEDED.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_BAD_NETPATH.value(), ENOENT);
+        errorToErrnoMapper.put(ERROR_NETWORK_ACCESS_DENIED.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_BAD_NET_NAME.value(), ENOENT);
+        errorToErrnoMapper.put(ERROR_FILE_EXISTS.value(), EEXIST);
+        errorToErrnoMapper.put(ERROR_CANNOT_MAKE.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_FAIL_I24.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_INVALID_PARAMETER.value(), EINVAL);
+        errorToErrnoMapper.put(ERROR_NO_PROC_SLOTS.value(), EAGAIN);
+        errorToErrnoMapper.put(ERROR_DRIVE_LOCKED.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_BROKEN_PIPE.value(), EPIPE);
+        errorToErrnoMapper.put(ERROR_DISK_FULL.value(), ENOSPC);
+        errorToErrnoMapper.put(ERROR_INVALID_TARGET_HANDLE.value(), EBADF);
+        errorToErrnoMapper.put(ERROR_INVALID_HANDLE.value(), EINVAL);
+        errorToErrnoMapper.put(ERROR_WAIT_NO_CHILDREN.value(), ECHILD);
+        errorToErrnoMapper.put(ERROR_CHILD_NOT_COMPLETE.value(), ECHILD);
+        errorToErrnoMapper.put(ERROR_DIRECT_ACCESS_HANDLE.value(), EBADF);
+        errorToErrnoMapper.put(ERROR_NEGATIVE_SEEK.value(), EINVAL);
+        errorToErrnoMapper.put(ERROR_SEEK_ON_DEVICE.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_DIR_NOT_EMPTY.value(), ENOTEMPTY);
+        errorToErrnoMapper.put(ERROR_DIRECTORY.value(), ENOTDIR);
+        errorToErrnoMapper.put(ERROR_NOT_LOCKED.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_BAD_PATHNAME.value(), ENOENT);
+        errorToErrnoMapper.put(ERROR_MAX_THRDS_REACHED.value(), EAGAIN);
+        errorToErrnoMapper.put(ERROR_LOCK_FAILED.value(), EACCES);
+        errorToErrnoMapper.put(ERROR_ALREADY_EXISTS.value(), EEXIST);
+        errorToErrnoMapper.put(ERROR_INVALID_STARTING_CODESEG.value(), ENOEXEC);
+        errorToErrnoMapper.put(ERROR_INVALID_STACKSEG.value(), ENOEXEC);
+        errorToErrnoMapper.put(ERROR_INVALID_MODULETYPE.value(), ENOEXEC);
+        errorToErrnoMapper.put(ERROR_INVALID_EXE_SIGNATURE.value(), ENOEXEC);
+        errorToErrnoMapper.put(ERROR_EXE_MARKED_INVALID.value(), ENOEXEC);
+        errorToErrnoMapper.put(ERROR_BAD_EXE_FORMAT.value(), ENOEXEC);
+        errorToErrnoMapper.put(ERROR_ITERATED_DATA_EXCEEDS_64k.value(), ENOEXEC);
+        errorToErrnoMapper.put(ERROR_INVALID_MINALLOCSIZE.value(), ENOEXEC);
+        errorToErrnoMapper.put(ERROR_DYNLINK_FROM_INVALID_RING.value(),ENOEXEC);
+        errorToErrnoMapper.put(ERROR_IOPL_NOT_ENABLED.value(), ENOEXEC);
+        errorToErrnoMapper.put(ERROR_INVALID_SEGDPL.value(), ENOEXEC);
+        errorToErrnoMapper.put(ERROR_AUTODATASEG_EXCEEDS_64k.value(), ENOEXEC);
+        errorToErrnoMapper.put(ERROR_RING2SEG_MUST_BE_MOVABLE.value(), ENOEXEC);
+        errorToErrnoMapper.put(ERROR_RELOC_CHAIN_XEEDS_SEGLIM.value(), ENOEXEC);
+        errorToErrnoMapper.put(ERROR_INFLOOP_IN_RELOC_CHAIN.value(), ENOEXEC);
+        errorToErrnoMapper.put(ERROR_FILENAME_EXCED_RANGE.value(), ENOENT);
+        errorToErrnoMapper.put(ERROR_NESTING_NOT_ALLOWED.value(), EAGAIN);
+        // ERROR_PIPE_LOCAL (in MRI)
+        errorToErrnoMapper.put(229, EPIPE);
+        errorToErrnoMapper.put(ERROR_BAD_PIPE.value(), EPIPE);
+        errorToErrnoMapper.put(ERROR_PIPE_BUSY.value(), EAGAIN);
+        errorToErrnoMapper.put(ERROR_NO_DATA.value(), EPIPE);
+        errorToErrnoMapper.put(ERROR_PIPE_NOT_CONNECTED.value(), EPIPE);
+        errorToErrnoMapper.put(ERROR_OPERATION_ABORTED.value(), EINTR);
+        errorToErrnoMapper.put(ERROR_NOT_ENOUGH_QUOTA.value(), ENOMEM);
+        errorToErrnoMapper.put(ERROR_MOD_NOT_FOUND.value(), ENOENT);
+        errorToErrnoMapper.put(WSAENAMETOOLONG.value(), ENAMETOOLONG);
+        errorToErrnoMapper.put(WSAENOTEMPTY.value(), ENOTEMPTY);
+        errorToErrnoMapper.put(WSAEINTR.value(), EINTR);
+        errorToErrnoMapper.put(WSAEBADF.value(), EBADF);
+        errorToErrnoMapper.put(WSAEACCES.value(), EACCES);
+        errorToErrnoMapper.put(WSAEFAULT.value(), EFAULT);
+        errorToErrnoMapper.put(WSAEINVAL.value(), EINVAL);
+        errorToErrnoMapper.put(WSAEMFILE.value(), EMFILE);
+    }
+
+    private final FileStat checkFdStat;
+
+    WindowsPOSIX(LibCProvider libc, POSIXHandler handler) {
+        super(libc, handler);
+        this.checkFdStat = new WindowsFileStat(this);
+    }
+    
+    @Override
+    public FileStat allocateStat() {
+        return new WindowsRawFileStat(this, handler);
+    }
+
+    public MsgHdr allocateMsgHdr() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return null;
+    }
+
+    public SocketMacros socketMacros() {
+        handler.unimplementedError(MethodName.getCallerMethodName());
+        return null;
+    }
+
+    @Override
+    public int kill(int pid, int signal) {
+        handler.unimplementedError("kill");
+
+        return -1;
+    }
+
+    @Override
+    public int kill(long pid, int signal) {
+        handler.unimplementedError("kill");
+
+        return -1;
+    }
+
+    @Override
+    public int chmod(String filename, int mode) {
+        return wlibc()._wchmod(WString.path(filename), mode);
+    }
+
+    @Override
+    public int chdir(String path) {
+        return wlibc()._wchdir(WString.path(path));
+    }
+    
+    @Override
+    public int chown(String filename, int user, int group) {
+        return 0;
+    }
+    
+    @Override
+    public int exec(String path, String[] argv) {
+        if (argv.length == 1) return spawn(true, argv[0], null, path, null);
+
+        return aspawn(true, null, argv, path, null);
+    }
+
+    @Override
+    public CharSequence crypt(CharSequence key, CharSequence salt) {
+        return JavaLibCHelper.crypt(key, salt);
+    }
+
+    @Override
+    public byte[] crypt(byte[] key, byte[] salt) {
+        return JavaLibCHelper.crypt(key, salt);
+    }
+
+    @Override
+    public int exec(String path, String[] argv, String[] envp) {
+        if (argv.length == 1) return spawn(true, argv[0], null, path, envp);
+
+        return aspawn(true, null, argv, path, envp);
+    }
+    
+    @Override
+    public int execv(String path, String[] argv) {
+        handler.unimplementedError("egid");
+
+        return -1;
+    }
+
+    @Override
+    public int getegid() {
+        handler.unimplementedError("egid");
+
+        return -1;
+    }
+
+    @Override
+    public int setegid(int egid) {
+        handler.unimplementedError("setegid");
+
+        return -1;
+    }
+
+    @Override
+    public int geteuid() {
+        return 0;
+    }
+
+    @Override
+    public int seteuid(int euid) {
+        handler.unimplementedError("seteuid");
+
+        return -1;
+    }
+
+    @Override
+    public int getuid() {
+        return 0;
+    }
+
+    @Override
+    public int setuid(int uid) {
+        handler.unimplementedError("setuid");
+
+        return -1;
+    }
+
+    @Override
+    public int getgid() {
+        return 0;
+    }
+
+    @Override
+    public int setgid(int gid) {
+        handler.unimplementedError("setgid");
+
+        return -1;
+    }
+
+    @Override
+    public int getpgid(int pid) {
+        handler.unimplementedError("getpgid");
+
+        return -1;
+    }
+    
+    @Override
+    public int getpgid() {
+        handler.unimplementedError("getpgid");
+
+        return -1;
+    }
+
+    @Override
+    public int setpgid(int pid, int pgid) {
+        handler.unimplementedError("setpgid");
+
+        return -1;
+    }
+    
+    @Override
+    public int getpriority(int which, int who) {
+        handler.unimplementedError("getpriority");
+
+        return -1;
+    }
+    
+    @Override
+    public int setpriority(int which, int who, int prio) {
+        handler.unimplementedError("setpriority");
+
+        return -1;
+    }
+
+    @Override
+    public int getpid(){
+        return wlibc()._getpid();
+    }
+
+    @Override
+    public int getppid() {
+        return 0;
+    }
+    
+    @Override
+    public int lchmod(String filename, int mode) {
+        handler.unimplementedError("lchmod");
+        
+        return -1;
+    }
+    
+    @Override
+    public int lchown(String filename, int user, int group) {
+        handler.unimplementedError("lchown");
+        
+        return -1;
+    }
+
+    @Override
+    public String gethostname() {
+        ByteBuffer buffer = ByteBuffer.allocate(64);
+        IntByReference len = new IntByReference(buffer.capacity() - 1);
+        if (!wlibc().GetComputerNameW(buffer, len)) return helper.gethostname();
+        buffer.limit(len.intValue() * 2);
+        return Charset.forName("UTF-16LE").decode(buffer).toString();
+    }
+    
+    public FileStat fstat(int fd) {
+        WindowsFileStat stat = new WindowsFileStat(this);
+        if (fstat(fd, stat) < 0) handler.error(Errno.valueOf(errno()), "fstat", "" + fd);
+        return stat;
+    }
+    
+    @Override
+    public int fstat(FileDescriptor fileDescriptor, FileStat stat) {
+        WindowsByHandleFileInformation info = new WindowsByHandleFileInformation(getRuntime());
+        if (wlibc().GetFileInformationByHandle(JavaLibCHelper.gethandle(fileDescriptor), info) == 0) return -1;
+
+        ((WindowsRawFileStat) stat).setup(info);
+
+        return 0;
+    }
+    
+    @Override
+    public FileStat lstat(String path) {
+        return stat(path);
+    }
+
+    @Override
+    public int lstat(String path, FileStat stat) {
+        return stat(path, stat); // windows stat honors windows equiv of softlinks and dangling ones.
+    }
+
+    @Override
+    public int stat(String path, FileStat stat) {
+        WindowsFileInformation info = new WindowsFileInformation(getRuntime());
+        byte[] wpath = WString.path(path, true);
+
+        if (wlibc().GetFileAttributesExW(wpath, 0, info) != 0) {
+            ((WindowsRawFileStat) stat).setup(path, info);
+        } else {
+            int e = errno();
+
+            if (e == ERROR_FILE_NOT_FOUND.intValue() || e == ERROR_PATH_NOT_FOUND.intValue()
+                    || e == ERROR_BAD_NETPATH.intValue()) {
+                return -1;
+            }
+
+            return findFirstFile(path, stat);
+        }
+
+        return 0;
+    }
+
+    // Public so we can test this via unit-testing.  This makes me wish we had a whole different interface for
+    // windows APIs user32/kernel32 that this class could consume easily.  We are clearly missing an abstraction
+    // or project here.
+    public int findFirstFile(String path, FileStat stat) {
+        byte[] wpath = WString.path(path, true);
+        WindowsFindData findData = new WindowsFindData(getRuntime());
+        HANDLE handle = wlibc().FindFirstFileW(wpath, findData);
+        if (!handle.isValid()) return -1;
+        wlibc().FindClose(handle);
+        ((WindowsRawFileStat) stat).setup(path, findData);
+
+        return 0;
+    }
+
+    @Override
+    public String readlink(String oldpath) {
+        handler.unimplementedError("readlink");
+
+        return null;
+    }
+
+    @Override
+    public Pointer environ() {
+        return getRuntime().getMemoryManager().newPointer(wlibc()._environ().get());
+    }
+
+    @Override
+    public int setenv(String envName, String envValue, int overwrite) {
+        if (envName.contains("=")) {
+            handler.error(EINVAL, "setenv", envName);
+            return -1;
+        }
+
+        // FIXME: We do not have getenv implemented yet.  So we are ignoring for now
+        // POSIX specified.  Existence is success if overwrite is 0.
+        // if (overwrite == 0 && getenv(envName) != null) return 0;
+        
+        if (!wlibc().SetEnvironmentVariableW(new WString(envName), new WString(envValue))) {
+            handler.error(EINVAL, "setenv", envName);
+            return -1;
+        }
+
+        return 0;
+    }
+
+    @Override
+    public int umask(int mask) {
+        return wlibc()._umask(mask);
+    }
+    
+    @Override
+    public int unsetenv(String envName) {
+        if (!wlibc().SetEnvironmentVariableW(new WString(envName), null)) {
+            handler.error(EINVAL, "unsetenv", envName);
+            return -1;
+        }
+        
+        return 0;
+    }
+
+
+
+    private static final int GENERIC_ALL = 0x10000000;
+    private static final int GENERIC_READ = 0x80000000;
+    private static final int GENERIC_WRITE = 0x40000000;
+    private static final int GENERIC_EXECUTE = 0x2000000;
+
+    private static final int FILE_SHARE_DELETE = 0x00000004;
+    private static final int FILE_SHARE_READ =  0x00000001;
+    private static final int FILE_SHARE_WRITE =  0x00000002;
+
+    private static final int CREATE_ALWAYS = 2;
+    private static final int CREATE_NEW = 1;
+    private static final int OPEN_ALWAYS = 4;
+    private static final int OPEN_EXISTING = 3;
+    private static final int TRUNCATE_EXISTING = 5;
+
+    public static final int FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;
+
+    @Override
+    public int utimes(String path, long[] atimeval, long[] mtimeval) {
+        FileTime aTime = timevalToFileTime(atimeval);
+        FileTime mTime = timevalToFileTime(mtimeval);
+        return setFileTime(path, aTime, mTime);
+    }
+
+    @Override
+    public int utimensat(int dirfd, String path, long[] atimespec, long[] mtimespec, int flag) {
+        FileTime aTime = timespecToFileTime(atimespec);
+        FileTime mTime = timespecToFileTime(mtimespec);
+        return setFileTime(path, aTime, mTime);
+    }
+
+    private FileTime timevalToFileTime(long[] timeval) {
+        if (timeval == null) {
+            return currentFileTime();
+        }
+
+        // timeval unit is (sec, microsec)
+        long unixEpochIn100ns = timeval[0] * 10000000 + timeval[1] * 10;
+        return unixTimeToFileTime(unixEpochIn100ns);
+    }
+
+    private FileTime timespecToFileTime(long[] timespec) {
+        if (timespec == null) {
+            return currentFileTime();
+        }
+
+        // timespec unit is (sec, nanosec)
+        long unixEpochIn100ns = timespec[0] * 10000000 + timespec[1] / 100;
+        return unixTimeToFileTime(unixEpochIn100ns);
+    }
+
+    private int setFileTime(String path, FileTime aTime, FileTime mTime) {
+        byte[] wpath = WindowsHelpers.toWPath(path);
+        HANDLE handle = wlibc().CreateFileW(wpath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
+                null, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
+        if (!handle.isValid()) {
+            return -1;             // TODO proper error handling
+        }
+
+        boolean timeSet = wlibc().SetFileTime(handle, null, aTime, mTime);
+        wlibc().CloseHandle(handle);
+
+        return timeSet ? 0 : -1;
+    }
+
+    /**
+     *
+     * @param unixEpochIn100ns epoch time in 100-ns precision
+     * @return associated FILETIME structure
+     */
+    private FileTime unixTimeToFileTime(long unixEpochIn100ns) {
+        // FILETIME is a 64-bit unsigned integer representing
+        // the number of 100-nanosecond intervals since January 1, 1601
+        // UNIX timestamp is number of seconds since January 1, 1970
+        // 116444736000000000 = 10_000_000 * 60 * 60 * 24 * 365 * 369 + 89 leap days
+        long ft = 116444736000000000L + unixEpochIn100ns;
+
+        //long ft = CommonFileInformation.asNanoSeconds(unixTimeSeconds);
+        FileTime fileTime = new FileTime(getRuntime());
+        fileTime.dwLowDateTime.set(ft & 0xFFFFFFFFL);
+        fileTime.dwHighDateTime.set((ft >> 32) & 0xFFFFFFFFL);
+        return fileTime;
+    }
+
+    private FileTime nullFileTime() {
+        FileTime fileTime = new FileTime(getRuntime());
+        fileTime.dwLowDateTime.set(0);
+        fileTime.dwHighDateTime.set(0);
+        return fileTime;
+    }
+
+    private FileTime currentFileTime() {
+      return unixTimeToFileTime(System.currentTimeMillis() * 10000);
+    }
+
+    @Override
+    public int wait(int[] status) {
+        handler.unimplementedError("wait");
+
+        return -1;
+    }
+
+    @Override
+    public int waitpid(int pid, int[] status, int flags) {
+        if (pid <= 0) {
+            handler.unimplementedError("waitpid");
+        }
+
+        HANDLE h = wlibc().OpenProcess(WindowsLibC.PROCESS_QUERY_INFORMATION, 0, pid);
+        if (h == null) {
+            return -1; // TODO: Throw exception
+        }
+
+        // Block
+        if ((flags & WaitFlags.WNOHANG.intValue()) != 0) {
+            wlibc().WaitForSingleObject(h, WindowsLibC.INFINITE);
+        }
+
+        IntByReference exitCode = new IntByReference();
+        wlibc().GetExitCodeProcess(h, exitCode);
+        wlibc().CloseHandle(h);
+        int code = exitCode.getValue();
+        if (code == 259) {
+            return 0;
+        } else {
+            status[0] = code;
+            return pid;
+        }
+    }
+
+    @Override
+    public int waitpid(long pid, int[] status, int flags) {
+        if (pid > Integer.MAX_VALUE) {
+            throw new java.lang.IllegalArgumentException("waitpid");
+        }
+        return waitpid((int) pid, status, flags);
+    }
+
+    @Override
+    public String getlogin() {
+        return helper.getlogin();
+    }
+
+    @Override
+    public int endgrent() {
+        return 0;
+    }
+
+    @Override
+    public int endpwent() {
+        return helper.endpwent();
+    }
+
+    @Override
+    public Group getgrent() {
+        return null;
+    }
+
+    @Override
+    public Passwd getpwent() {
+        return null;
+    }
+
+    @Override
+    public Group getgrgid(int which) {
+        return null;
+    }
+
+    @Override
+    public Passwd getpwnam(String which) {
+        return null;
+    }
+
+    @Override
+    public Group getgrnam(String which) {
+        return null;
+    }
+    
+    @Override
+    public int setgrent() {
+        return 0;
+    }
+    
+    @Override
+    public int setpwent() {
+        return helper.setpwent();
+    }
+
+    @Override
+    public Passwd getpwuid(int which) {
+        return null;
+    }
+
+    @Override
+    public boolean isatty(FileDescriptor fd) {
+        HANDLE handle = JavaLibCHelper.gethandle(fd);
+
+        int type = wlibc().GetFileType(handle);
+        return type == FILE_TYPE_CHAR;
+    }
+
+    @Override
+    public int isatty(int fd) {
+        HANDLE handle = JavaLibCHelper.gethandle(fd);
+
+        int type = wlibc().GetFileType(handle);
+        return type == FILE_TYPE_CHAR ? 1 : 0;
+    }
+
+    @Override
+    public int mkdir(String path, int mode) {
+        WString widePath = WString.path(path);
+        int res = -1;
+        
+        if (wlibc()._wmkdir(widePath) == 0) {
+            res = wlibc()._wchmod(widePath, mode);
+        }
+        
+        if (res < 0) {
+            int errno = errno();
+            handler.error(Errno.valueOf(errno), "mkdir", path);
+        }
+        return res;
+    }
+    
+    // FIXME: Should this and other fields be part of constantine/jnr-constants?
+    static final int FILE_ATTRIBUTE_READONLY = 1;
+    static final int INVALID_FILE_ATTRIBUTES = -1;
+    
+    /**
+     * The logic here is a bit strange and this copies MRI (Ruby) which may not be language
+     * agnostic, but windows (win7 and others) automatically mark folders as read-only when 
+     * it contains other files and folders within it.  This document explains more: 
+     * http://support.microsoft.com/kb/326549
+     * I think the logic is based around idea that if you removed all other files it would
+     * be empty but will stay marked as read-only.
+     *
+     * @param path the path to remove
+     * @return 0 if successful, -1 if failed
+     */
+    @Override
+    public int rmdir(String path) {
+        WString pathW = WString.path(path);
+        int attr = wlibc().GetFileAttributesW(pathW);
+        boolean isReadOnly = attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_READONLY) != 0;
+        
+        if (isReadOnly) wlibc().SetFileAttributesW(pathW, attr & ~FILE_ATTRIBUTE_READONLY);
+        
+        if (!wlibc().RemoveDirectoryW(pathW)) {
+            int errno = errno();
+
+            if (isReadOnly) wlibc().SetFileAttributesW(pathW, attr & FILE_ATTRIBUTE_READONLY);
+            
+            handler.error(mapErrorToErrno(errno), "rmdir", path);
+            
+            return -1;
+        }
+
+        return 0;
+    }
+
+    @Override
+    public int link(String oldpath, String newpath) {
+        boolean linkCreated =  wlibc().CreateHardLinkW(WString.path(newpath), WString.path(oldpath), null);
+
+        if (!linkCreated) {
+            int error = errno();
+            handler.error(mapErrorToErrno(error), "link", oldpath + " or " + newpath);
+            return error;
+        } else {
+            return 0;
+        }
+    }
+    
+    /**
+     * @param overlay is P_OVERLAY if true and P_NOWAIT if false
+     * @param program to be invoked
+     * @param argv is all args including argv0 being what is executed
+     * @param path is path to be searched when needed (delimited by ; on windows)
+     * @param envp is a set of KEY=VALUE strings to be set in the child process
+     * @return the pid
+     */    
+    public int aspawn(boolean overlay, String program, String[] argv, String path, String[] envp) {
+        try {
+        if (argv.length == 0) return -1;
+        
+        String[] cmds = WindowsHelpers.processCommandArgs(this, program, argv, path);
+ 
+        return childResult(createProcess("aspawn", cmds[0], cmds[1], null, null, null, null, envp), overlay);
+        } catch (Exception e) {
+            return -1;
+        }
+    }
+
+    public int pipe(int[] fds) {
+        // TODO (nirvdrum 06-May-15) Maybe not hard-code the psize value. But figure out a sensible way to handle textmode.
+        return ((WindowsLibC) libc())._pipe(fds, 512, 0);
+    }
+
+    public int truncate(CharSequence path, long length) {
+        // Windows doesn't have a native truncate() equivalent, but it does have a native ftruncate() equivalent.
+        // In order to call the ftruncate() equivalent, we must convert a path to a FD.  We do that by wrapping the
+        // ftruncate() call with open() and close().
+
+        // Permissions are ignored since we're not using O_CREAT.
+        int fd = libc().open(path, OpenFlags.O_WRONLY.intValue(), 0);
+        if (fd == -1) {
+            return -1;
+        }
+
+        if (libc().ftruncate(fd, length) == -1) {
+            return -1;
+        }
+
+        if (libc().close(fd) == -1) {
+            return -1;
+        }
+
+        // truncate() returns 0 on success.
+        return 0;
+    }
+
+    public int fcntlInt(int fd, Fcntl fcntl, int arg) {
+        switch(fcntl) {
+            case F_GETFD: {
+                if (checkFd(fd) == -1) {
+                    return -1;
+                } else {
+                    // This is a gigantic hack.  Indicate that Windows does not support close-on-exec.
+                    return 0;
+                }
+            }
+
+            case F_SETFD: {
+                if (checkFd(fd) == -1) {
+                    return -1;
+                } else {
+                    // This is a gigantic hack.  Indicate that Windows does not support close-on-exec by no-oping.
+                    return 0;
+                }
+            }
+
+            case F_GETFL: {
+                if (checkFd(fd) == -1) {
+                    return -1;
+                } else {
+                    // TODO (nirvdrum 06-May-15): Look up the actual flags rather than optimistically hard-coding this set.
+                    return OpenFlags.O_RDWR.intValue();
+                }
+            }
+
+            default: {
+                handler.unimplementedError("fcntl");
+
+                return -1;
+            }
+        }
+    }
+    
+    private WindowsLibC wlibc() {
+        return (WindowsLibC) libc();
+    }
+    
+    /**
+     * @param overlay is P_OVERLAY if true and P_NOWAIT if false
+     * @param command full command string
+     * @param program program to be invoked
+     * @param path is path to be searched when needed (delimited by ; on windows)
+     * @param envp is a set of KEY=VALUE strings to be set in the child process
+     * @return the pid
+     */
+    public int spawn(boolean overlay, String command, String program, String path, String[] envp) {
+        if (command == null) return -1;
+
+        String[] cmds = WindowsHelpers.processCommandLine(this, command, program, path);
+
+        return childResult(createProcess("spawn", cmds[0], cmds[1], null, null, null, null, envp), overlay);
+    }
+    
+    private int childResult(WindowsChildRecord child, boolean overlay) {
+        if (child == null) return -1;
+
+        if (overlay) {
+            IntByReference exitCode = new IntByReference();
+
+            WindowsLibC libc = (WindowsLibC) libc();
+            HANDLE handle = child.getProcess();
+            
+            libc.WaitForSingleObject(handle, WindowsLibC.INFINITE);
+            libc.GetExitCodeProcess(handle, exitCode);
+            libc.CloseHandle(handle);
+            System.exit(exitCode.getValue());
+        }
+
+        return child.getPid();
+    }
+
+    private static Errno mapErrorToErrno(int error) {
+        Errno errno = errorToErrnoMapper.get(error);
+        if (errno == null) {
+            errno = __UNKNOWN_CONSTANT__;
+        }
+        return errno;
+    }
+
+    private static final int STARTF_USESTDHANDLES = 0x00000100;
+    
+    // Used by spawn and aspawn (Note: See fixme below...envp not hooked up yet)
+    private WindowsChildRecord createProcess(String callingMethodName, String command, String program, 
+            WindowsSecurityAttributes securityAttributes, HANDLE input,
+            HANDLE output, HANDLE error, String[] envp) {
+        if (command == null && program == null) {
+            handler.error(EFAULT, callingMethodName, "no command or program specified");
+            return null;
+        }
+        
+        if (securityAttributes == null) {
+            securityAttributes = new WindowsSecurityAttributes(getRuntime());
+        }
+        
+        WindowsStartupInfo startupInfo = new WindowsStartupInfo(getRuntime());
+        
+        startupInfo.setFlags(STARTF_USESTDHANDLES);
+        startupInfo.setStandardInput(input != null ? input :
+                wlibc().GetStdHandle(WindowsLibC.STD_INPUT_HANDLE));
+        startupInfo.setStandardOutput(output != null ? output :
+                wlibc().GetStdHandle(WindowsLibC.STD_OUTPUT_HANDLE));
+        startupInfo.setStandardError(error != null ? input :
+                wlibc().GetStdHandle(WindowsLibC.STD_ERROR_HANDLE));
+        
+        int creationFlags = WindowsLibC.NORMAL_PRIORITY_CLASS | WindowsLibC.CREATE_UNICODE_ENVIRONMENT;
+        WindowsProcessInformation processInformation = new WindowsProcessInformation(getRuntime());
+
+        // FIXME: Convert envp into useful wideEnv
+        Pointer wideEnv = null;
+        byte[] programW = WindowsHelpers.toWString(program);
+        byte[] cwd = WindowsHelpers.toWString(WindowsHelpers.escapePath(handler.getCurrentWorkingDirectory().toString()) +"\\");
+        ByteBuffer commandW = ByteBuffer.wrap(WindowsHelpers.toWString(command));
+        boolean returnValue = wlibc().CreateProcessW(programW, commandW, 
+                securityAttributes, securityAttributes, 
+                securityAttributes.getInheritHandle() ? 1: 0, creationFlags, wideEnv, cwd, 
+                startupInfo, processInformation);
+        
+        if (!returnValue) return null;
+        
+        wlibc().CloseHandle(processInformation.getThread());
+        
+        // TODO: On winnt reverse sign of pid
+        return new WindowsChildRecord(processInformation.getProcess(), processInformation.getPid());
+    }
+
+    private int checkFd(int fd) {
+        // There might be a lighter-weight check, but we basically want to
+        // make sure the FD is valid and the effective user can access it,
+        // since we need to simulate fcntl semantics.
+        return libc().fstat(fd, checkFdStat);
+    }
+
+    public static final PointerConverter PASSWD = new PointerConverter() {
+        public Object fromNative(Object arg, FromNativeContext ctx) {
+            throw new RuntimeException("no support for native passwd");
+        }
+    };
+
+    public int mkfifo(String filename, int mode) {
+        handler.unimplementedError("mkfifo");
+
+        return -1;
+    }
+
+    public Timeval allocateTimeval() {
+        return new DefaultNativeTimeval(getRuntime());
+    }
+
+    // TODO: Replace with Win32 calls. See jnr/jnr-posix#98.
+    public int gettimeofday(Timeval tv) {
+        long currentMillis = System.currentTimeMillis();
+        tv.sec(currentMillis / 1000);
+        tv.usec(currentMillis % 1000 * 1000);
+        return 0;
+    }
+}
diff --git a/src/main/java/jnr/posix/WindowsProcessInformation.java b/src/main/java/jnr/posix/WindowsProcessInformation.java
new file mode 100644
index 0000000..e2a8035
--- /dev/null
+++ b/src/main/java/jnr/posix/WindowsProcessInformation.java
@@ -0,0 +1,33 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package jnr.posix;
+
+/**
+ *
+ * @author enebo
+ */
+public class WindowsProcessInformation extends jnr.ffi.Struct {
+    final Pointer hProcess = new Pointer();
+    final Pointer hThread = new Pointer();
+    final Unsigned32 dwProcessId = new Unsigned32();
+    final Unsigned32 dwThreadId = new Unsigned32();
+
+    public WindowsProcessInformation(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+    
+    public HANDLE getThread() {
+        return new HANDLE(hThread.get());
+    }
+    
+    public HANDLE getProcess() {
+        return new HANDLE(hProcess.get());
+    }
+    
+    public int getPid() {
+        return dwProcessId.intValue();
+    }
+}
diff --git a/src/main/java/jnr/posix/WindowsRawFileStat.java b/src/main/java/jnr/posix/WindowsRawFileStat.java
new file mode 100644
index 0000000..8c0a048
--- /dev/null
+++ b/src/main/java/jnr/posix/WindowsRawFileStat.java
@@ -0,0 +1,212 @@
+package jnr.posix;
+
+import jnr.posix.util.WindowsHelpers;
+import jnr.posix.windows.CommonFileInformation;
+
+public class WindowsRawFileStat extends AbstractJavaFileStat implements NanosecondFileStat {
+    private int st_atime;
+    private long st_atimensec;
+    private long st_mtimensec;
+    private long st_ctimensec;
+    private int st_rdev;
+    private int st_dev;
+    private int st_nlink;
+    private int st_mode;
+    private long st_size;
+    private int st_ctime;
+    private int st_mtime;
+
+    public WindowsRawFileStat(POSIX posix, POSIXHandler handler) {
+        super(posix, handler);
+    }
+
+    public void setup(String path, CommonFileInformation fileInfo) {
+        st_mode = fileInfo.getMode(path);
+        setup(fileInfo);
+
+        if (WindowsHelpers.isDriveLetterPath(path)) {
+            int letterAsNumber = Character.toUpperCase(path.charAt(0)) - 'A';
+            st_rdev = letterAsNumber;
+            st_dev = letterAsNumber;
+        }
+    }
+
+    public void setup(CommonFileInformation fileInfo) {
+        long atime = fileInfo.getLastAccessTimeNanoseconds();
+        st_atimensec = atime % CommonFileInformation.NANOSECONDS;
+        st_atime = (int) (atime / CommonFileInformation.NANOSECONDS);
+        long mtime = fileInfo.getLastWriteTimeNanoseconds();
+        st_mtimensec = mtime % CommonFileInformation.NANOSECONDS;
+        st_mtime = (int) (mtime / CommonFileInformation.NANOSECONDS);
+        long ctime = fileInfo.getCreationTimeNanoseconds();
+        st_ctimensec = ctime % CommonFileInformation.NANOSECONDS;
+        st_ctime = (int) (ctime / CommonFileInformation.NANOSECONDS);
+        st_size = isDirectory() ? 0 : fileInfo.getFileSize();
+        st_nlink = 1;
+        st_mode &= ~(S_IWGRP | S_IWOTH);
+    }
+
+    public int mode() {
+        return st_mode;
+    }
+
+    @Override
+    public long mtime() {
+        return st_mtime;
+    }
+
+    public long atime() {
+        return st_atime;
+    }
+
+    @Override
+    public long aTimeNanoSecs() {
+        return st_atimensec;
+    }
+
+    @Override
+    public long cTimeNanoSecs() {
+        return st_ctimensec;
+    }
+
+    @Override
+    public long mTimeNanoSecs() {
+        return st_mtimensec;
+    }
+
+    public long dev() {
+        return st_dev;
+    }
+
+    public int nlink() {
+        return st_nlink;
+    }
+
+    public long rdev() {
+        return st_rdev;
+    }
+
+    @Override
+    public long st_size() {
+        return st_size;
+    }
+
+    @Override
+    public long ctime() {
+        return st_ctime;
+    }
+
+    public boolean isDirectory() {
+        return (mode() & S_IFMT) == S_IFDIR;
+    }
+
+    public boolean isEmpty() {
+        return st_size() == 0;
+    }
+
+    @Override
+    public boolean isExecutable() {
+        if (isOwned()) return (mode() & S_IXUSR) != 0;
+        if (isGroupOwned()) return (mode() & S_IXGRP) != 0;
+        if ((mode() & S_IXOTH) != 0) return false;
+
+        return true;
+    }
+
+    @Override
+    public boolean isExecutableReal() {
+        if (isROwned()) return (mode() & S_IXUSR) != 0;
+        if (groupMember(gid())) return (mode() & S_IXGRP) != 0;
+        if ((mode() & S_IXOTH) != 0) return false;
+
+        return true;
+    }
+
+    public boolean isFile() {
+        return (mode() & S_IFMT) == S_IFREG;
+    }
+
+    public boolean isFifo() {
+        return (mode() & S_IFMT) == S_IFIFO;
+    }
+
+    public boolean isGroupOwned() {
+        return groupMember(gid());
+    }
+
+    public boolean isIdentical(FileStat other) {
+        return dev() == other.dev() && ino() == other.ino();
+    }
+
+    public boolean isNamedPipe() {
+        return (mode() & S_IFIFO) != 0;
+    }
+
+    // FIXME: Implement
+    @Override
+    public boolean isOwned() {
+        return true;
+    }
+
+    // FIXME: Implement
+    @Override
+    public boolean isROwned() {
+        return true;
+    }
+
+    @Override
+    public boolean isReadable() {
+        if (isOwned()) return (mode() & S_IRUSR) != 0;
+        if (isGroupOwned()) return (mode() & S_IRGRP) != 0;
+        if ((mode() & S_IROTH) != 0) return false;
+
+        return true;
+    }
+
+    @Override
+    public boolean isReadableReal() {
+        if (isROwned()) return (mode() & S_IRUSR) != 0;
+        if (groupMember(gid())) return (mode() & S_IRGRP) != 0;
+        if ((mode() & S_IROTH) != 0) return false;
+
+        return true;
+    }
+
+    public boolean isSetgid() {
+        return (mode() & S_ISGID) != 0;
+    }
+
+    public boolean isSetuid() {
+        return (mode() & S_ISUID) != 0;
+    }
+
+    public boolean isSocket() {
+        return (mode() & S_IFMT) == S_IFSOCK;
+    }
+
+    public boolean isSticky() {
+        return (mode() & S_ISVTX) != 0;
+    }
+
+    public boolean isSymlink() {
+        return (mode() & S_IFMT) == S_IFLNK;
+    }
+
+    @Override
+    public boolean isWritable() {
+        if (isOwned()) return (mode() & S_IWUSR) != 0;
+        if (isGroupOwned()) return (mode() & S_IWGRP) != 0;
+        if ((mode() & S_IWOTH) != 0) return false;
+
+        return true;
+    }
+
+    @Override
+    public boolean isWritableReal() {
+        if (isROwned()) return (mode() & S_IWUSR) != 0;
+        if (groupMember(gid())) return (mode() & S_IWGRP) != 0;
+        if ((mode() & S_IWOTH) != 0) return false;
+
+        return true;
+    }
+}
diff --git a/src/main/java/jnr/posix/WindowsSecurityAttributes.java b/src/main/java/jnr/posix/WindowsSecurityAttributes.java
new file mode 100644
index 0000000..a2a4b33
--- /dev/null
+++ b/src/main/java/jnr/posix/WindowsSecurityAttributes.java
@@ -0,0 +1,28 @@
+package jnr.posix;
+
+import jnr.ffi.*;
+
+/**
+ *
+ */
+public class WindowsSecurityAttributes extends jnr.ffi.Struct {
+    public final Unsigned32 length = new Unsigned32();
+    public final Pointer securityDescriptor = new Pointer();
+    public final WBOOL inheritHandle = new WBOOL();
+
+    public WindowsSecurityAttributes(jnr.ffi.Runtime runtime) {
+        super(runtime);
+        
+        // This seems like the sensible defaults for this.
+        length.set(Struct.size(this));
+        inheritHandle.set(true);
+    }
+    
+    public long getLength() {
+        return length.get();
+    }
+
+    public boolean getInheritHandle() {
+        return inheritHandle.get();
+    }
+}
diff --git a/src/main/java/jnr/posix/WindowsStartupInfo.java b/src/main/java/jnr/posix/WindowsStartupInfo.java
new file mode 100644
index 0000000..1058aff
--- /dev/null
+++ b/src/main/java/jnr/posix/WindowsStartupInfo.java
@@ -0,0 +1,51 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package jnr.posix;
+
+/**
+ *
+ * @author enebo
+ */
+public class WindowsStartupInfo extends jnr.ffi.Struct {
+    public final Unsigned32  cb = new Unsigned32();
+    public final Pointer lpReserved = new Pointer(); //new UTF8String();
+    public final Pointer lpDesktop = new Pointer(); //UTF8String();
+    public final Pointer lpTitle = new Pointer(); //new UTF8String();
+    public final Unsigned32  dwX = new Unsigned32();
+    public final Unsigned32  dwY = new Unsigned32();
+    public final Unsigned32  dwXSize = new Unsigned32();
+    public final Unsigned32  dwYSize = new Unsigned32();
+    public final Unsigned32  dwXCountChars = new Unsigned32();
+    public final Unsigned32  dwYCountChars = new Unsigned32();
+    public final Unsigned32  dwFillAttribute = new Unsigned32();
+    public final Unsigned32  dwFlags = new Unsigned32();
+    public final Unsigned16   wShowWindow = new Unsigned16();
+    public final Unsigned16   cbReserved2 = new Unsigned16();
+    public final Pointer lpReserved2 = new Pointer();
+    public final Pointer standardInput = new Pointer();
+    public final Pointer standardOutput = new Pointer();
+    public final Pointer standardError = new Pointer();
+  
+    public WindowsStartupInfo(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+  
+    public void setFlags(int value) {
+        dwFlags.set(value);
+    }
+
+    public void setStandardInput(HANDLE standardInput) {
+        this.standardInput.set(standardInput.toPointer());
+    }
+
+    public void setStandardOutput(HANDLE standardOutput) {
+        this.standardOutput.set(standardOutput.toPointer());
+    }
+
+    public void setStandardError(HANDLE standardError) {
+        this.standardError.set(standardError.toPointer());
+    }
+}
diff --git a/src/main/java/jnr/posix/util/Chmod.java b/src/main/java/jnr/posix/util/Chmod.java
new file mode 100644
index 0000000..202ea0a
--- /dev/null
+++ b/src/main/java/jnr/posix/util/Chmod.java
@@ -0,0 +1,101 @@
+package jnr.posix.util;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * Honor semantics of chmod as best we can in pure Java.  Note, this uses reflection to be 
+ * more tolerant of different Java versions. 
+ */
+public class Chmod {
+    private static final boolean CHMOD_API_AVAILABLE;
+    private static final Method setWritable;
+    private static final Method setReadable;
+    private static final Method setExecutable;
+    
+    static {
+        boolean apiAvailable = false;
+        Method setWritableVar = null;
+        Method setReadableVar = null;
+        Method setExecutableVar = null;
+        try {
+            setWritableVar = File.class.getMethod("setWritable", new Class[] {Boolean.TYPE, Boolean.TYPE});
+            setReadableVar = File.class.getMethod("setReadable", new Class[] {Boolean.TYPE, Boolean.TYPE});
+            setExecutableVar = File.class.getMethod("setExecutable", new Class[] {Boolean.TYPE, Boolean.TYPE});
+            apiAvailable = true;
+        } catch (Exception e) {
+            // failed to load methods, no chmod API available
+        }
+        setWritable = setWritableVar;
+        setReadable = setReadableVar;
+        setExecutable = setExecutableVar;
+        CHMOD_API_AVAILABLE = apiAvailable;
+    }
+    
+    public static int chmod(File file, String mode) {
+        if (CHMOD_API_AVAILABLE) {
+            // fast version
+            char other = '0';
+            if (mode.length() >= 1) {
+                other = mode.charAt(mode.length() - 1);
+            }
+            //char group = mode.charAt(mode.length() - 2);
+            char user = '0';
+            if (mode.length() >= 3) {
+                user = mode.charAt(mode.length() - 3);
+            }
+            //char setuidgid = mode.charAt(mode.length() - 3);
+            
+            // group and setuid/gid are ignored, no way to do them fast. Should we fall back on slow?
+            if (!setPermissions(file, other, false)) return -1;
+            if (!setPermissions(file, user, true)) return -1;
+            return 0;
+        } else {
+            // slow version
+            try {
+                Process chmod = Runtime.getRuntime().exec("/bin/chmod " + mode + " " + file.getAbsolutePath());
+                chmod.waitFor();
+                return chmod.exitValue();
+            } catch (IOException ioe) {
+                // FIXME: ignore?
+            } catch (InterruptedException ie) {
+                Thread.currentThread().interrupt();
+            }
+        }
+        return -1;
+    }
+    
+    private static boolean setPermissions(File file, char permChar, boolean userOnly) {
+        int permValue = Character.digit(permChar, 8);
+        
+        try {
+            if ((permValue & 1) != 0) {
+                setExecutable.invoke(file, new Object[] {Boolean.TRUE, Boolean.valueOf(userOnly)});
+            } else {
+                setExecutable.invoke(file, new Object[] {Boolean.FALSE, Boolean.valueOf(userOnly)});
+            }
+            
+            if ((permValue & 2) != 0) {
+                setWritable.invoke(file, new Object[] {Boolean.TRUE, Boolean.valueOf(userOnly)});
+            } else {
+                setWritable.invoke(file, new Object[] {Boolean.FALSE, Boolean.valueOf(userOnly)});
+            }
+            
+            if ((permValue & 4) != 0) {
+                setReadable.invoke(file, new Object[] {Boolean.TRUE, Boolean.valueOf(userOnly)});
+            } else {
+                setReadable.invoke(file, new Object[] {Boolean.FALSE, Boolean.valueOf(userOnly)});
+            }
+            
+            return true;
+        } catch (IllegalAccessException iae) {
+            // ignore, return false below
+        } catch (InvocationTargetException ite) {
+            // ignore, return false below
+        }
+        
+        return false;
+    }
+}
diff --git a/src/main/java/jnr/posix/util/DefaultPOSIXHandler.java b/src/main/java/jnr/posix/util/DefaultPOSIXHandler.java
new file mode 100644
index 0000000..a5ef603
--- /dev/null
+++ b/src/main/java/jnr/posix/util/DefaultPOSIXHandler.java
@@ -0,0 +1,74 @@
+package jnr.posix.util;
+
+import jnr.constants.platform.Errno;
+import jnr.posix.POSIXHandler;
+
+import java.io.File;
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.util.Arrays;
+import java.util.IllegalFormatException;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A POSIXHandler with reasonable default behavior.
+ */
+public class DefaultPOSIXHandler implements POSIXHandler {
+    public void error(Errno error, String extraData) {
+        throw new RuntimeException("native error " + error.description() + " " + extraData);
+    }
+
+    public void error(Errno error, String methodName, String extraData) {
+        throw new RuntimeException("native error calling " + methodName + ": " + error.description() + " " + extraData);
+    }
+    
+    public void unimplementedError(String methodName) {
+        throw new IllegalStateException(methodName + " is not implemented in jnr-posix");
+    }
+
+    public void warn(WARNING_ID id, String message, Object... data) {
+        String msg;
+        try {
+            msg = String.format(message, data);
+        }
+        catch (IllegalFormatException e) {
+            msg = message + " " + Arrays.toString(data);
+        }
+        Logger.getLogger("jnr-posix").log(Level.WARNING, msg);
+    }
+
+    public boolean isVerbose() {
+        return false;
+    }
+
+    public File getCurrentWorkingDirectory() {
+        return new File(".");
+    }
+
+    public String[] getEnv() {
+        String[] envp = new String[System.getenv().size()];
+        int i = 0;
+        for (Map.Entry<String, String> pair : System.getenv().entrySet()) {
+            envp[i++] = new StringBuilder(pair.getKey()).append("=").append(pair.getValue()).toString();
+        }
+        return envp;
+    }
+
+    public InputStream getInputStream() {
+        return System.in;
+    }
+
+    public PrintStream getOutputStream() {
+        return System.out;
+    }
+
+    public int getPID() {
+        return 0;
+    }
+
+    public PrintStream getErrorStream() {
+        return System.err;
+    }
+}
diff --git a/src/main/java/jnr/posix/util/ExecIt.java b/src/main/java/jnr/posix/util/ExecIt.java
new file mode 100644
index 0000000..a79512f
--- /dev/null
+++ b/src/main/java/jnr/posix/util/ExecIt.java
@@ -0,0 +1,157 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Copyright (C) 2008 JRuby Community
+ * 
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+
+package jnr.posix.util;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import jnr.posix.POSIXHandler;
+
+public class ExecIt {
+    protected final POSIXHandler handler;
+
+    /** Creates a new instance of ShellLauncher
+     *
+     * @param handler the {@link POSIXHandler} to use
+     */
+    public ExecIt(POSIXHandler handler) {
+        this.handler = handler;
+    }
+
+    public int runAndWait(String... args) throws IOException, InterruptedException {
+        return runAndWait(handler.getOutputStream(), args);
+    }
+
+    public int runAndWait(OutputStream output, String... args) throws IOException, InterruptedException {
+        return runAndWait(output, handler.getErrorStream(), args);
+    }
+
+    public int runAndWait(OutputStream output, OutputStream error, String... args) throws IOException, InterruptedException {
+        Process process = run(args);
+
+        handleStreams(process, handler.getInputStream(), output, error);
+
+        return process.waitFor();
+    }
+
+    public Process run(String... args) throws IOException {
+        File cwd = handler.getCurrentWorkingDirectory();
+          
+        return Runtime.getRuntime().exec(args, handler.getEnv(), cwd);        
+    }
+
+    private static class StreamPumper extends Thread {
+        private InputStream in;
+        private OutputStream out;
+        private boolean onlyIfAvailable;
+        private volatile boolean quit;
+        private final Object waitLock = new Object();
+        StreamPumper(InputStream in, OutputStream out, boolean avail) {
+            this.in = in;
+            this.out = out;
+            this.onlyIfAvailable = avail;
+        }
+        
+        public void run() {
+            byte[] buf = new byte[1024];
+            int numRead;
+            boolean hasReadSomething = false;
+            try {
+                while (!quit) {
+                    // The problem we trying to solve below: STDIN in Java is blocked and 
+                    // non-interruptible, so if we invoke read on it, we might never be able to
+                    // interrupt such thread.  So, we use in.available() to see if there is any 
+                    // input ready, and only then read it. But this approach can't tell whether 
+                    // the end of stream reached or not, so we might end up looping right at the
+                    // end of the stream.  Well, at least, we can improve the situation by checking
+                    // if some input was ever available, and if so, not checking for available 
+                    // anymore, and just go to read.
+                    if (onlyIfAvailable && !hasReadSomething) {
+                        if (in.available() == 0) {
+                            synchronized (waitLock) {
+                                waitLock.wait(10);                                
+                            }
+                            continue;
+                        } else {
+                            hasReadSomething = true;
+                        }
+                    }
+
+                    if ((numRead = in.read(buf)) == -1) {
+                        break;
+                    }
+                    out.write(buf, 0, numRead);
+                }
+            } catch (Exception e) {
+            } finally {
+                if (onlyIfAvailable) {
+                    // We need to close the out, since some
+                    // processes would just wait for the stream
+                    // to be closed before they process its content,
+                    // and produce the output. E.g.: "cat".
+                    try { out.close(); } catch (IOException ioe) {}
+                }                
+            }
+        }
+        
+        public void quit() {
+            this.quit = true;
+            synchronized (waitLock) {
+                waitLock.notify();                
+            }
+        }
+    }
+
+    private void handleStreams(Process p, InputStream in, OutputStream out, OutputStream err) throws IOException {
+        InputStream pOut = p.getInputStream();
+        InputStream pErr = p.getErrorStream();
+        OutputStream pIn = p.getOutputStream();
+
+        StreamPumper t1 = new StreamPumper(pOut, out, false);
+        StreamPumper t2 = new StreamPumper(pErr, err, false);
+        StreamPumper t3 = new StreamPumper(in, pIn, true);
+        t1.start();
+        t2.start();
+        t3.start();
+
+        try { t1.join(); } catch (InterruptedException ie) {}
+        try { t2.join(); } catch (InterruptedException ie) {}
+        t3.quit();
+
+        try { err.flush(); } catch (IOException io) {}
+        try { out.flush(); } catch (IOException io) {}
+
+        try { pIn.close(); } catch (IOException io) {}
+        try { pOut.close(); } catch (IOException io) {}
+        try { pErr.close(); } catch (IOException io) {}
+
+    }
+}
diff --git a/src/main/java/jnr/posix/util/FieldAccess.java b/src/main/java/jnr/posix/util/FieldAccess.java
new file mode 100644
index 0000000..bdbe093
--- /dev/null
+++ b/src/main/java/jnr/posix/util/FieldAccess.java
@@ -0,0 +1,31 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package jnr.posix.util;
+
+import java.lang.reflect.Field;
+
+/**
+ *
+ * @author nicksieger
+ */
+public class FieldAccess {
+    public static Field getProtectedField(Class klass, String fieldName) {
+        Field field = null;
+        try {
+            field = klass.getDeclaredField(fieldName);
+            field.setAccessible(true);
+        } catch (Exception e) {
+        }
+        return field;
+    }
+    public static Object getProtectedFieldValue(Class klass, String fieldName, Object instance) {
+        try {
+            Field f = getProtectedField(klass, fieldName);
+            return f.get(instance);
+        } catch (Exception e) {
+            throw new IllegalArgumentException(e);
+        }
+    }
+}
diff --git a/src/main/java/jnr/posix/util/Finder.java b/src/main/java/jnr/posix/util/Finder.java
new file mode 100644
index 0000000..85cc34e
--- /dev/null
+++ b/src/main/java/jnr/posix/util/Finder.java
@@ -0,0 +1,131 @@
+package jnr.posix.util;
+
+import java.io.File;
+import java.util.*;
+
+import jnr.posix.FileStat;
+import jnr.posix.POSIX;
+
+public class Finder {
+    private static final Collection<String> EXECUTABLE_EXTENSIONS
+            = Collections.unmodifiableSet(new HashSet<String>(Arrays.asList(".exe", ".com", ".cmd", ".bat")));
+
+    public static String findFileInPath(POSIX posix, String name, String path) {
+        if (path == null || path.length() == 0) path = System.getenv("PATH");
+        
+        // MRI sets up a bogus path which seems like it would violate security
+        // if nothing else since if I don't have /usr/bin in my path but I end
+        // up executing it anyways???  Returning original name and hoping for 
+        // best.
+        if (path == null || path.length() == 0) return name;
+        
+        return findFileCommon(posix, name, path, true);
+    }
+    
+    public static String findFileCommon(POSIX posix, String name, String path, boolean executableOnly) {
+        // No point looking for nothing...
+        if (name == null || name.length() == 0) return name;
+        
+        int length = name.length();
+        boolean isAbsolute = false;
+        boolean isPath = false;
+        int i = 0;
+        if (Platform.IS_WINDOWS) {
+            if (length > 1 && Character.isLetter(name.charAt(0)) && name.charAt(1) == ':') {
+                i = 2;
+                isAbsolute = true;
+            }
+
+            int extensionIndex = -1;
+            char c = name.charAt(i);
+            if (i == '/' || i == '\\') {
+                i++;
+                c = name.charAt(i);
+                isAbsolute = true;
+            }
+
+            // Is this a partial path and does it contain an explicit 
+            // file extension?
+            for (; i < length; i++) {
+                switch (c) {
+                    case '/':
+                    case '\\':
+                        isPath = true;
+                        extensionIndex = -1;
+                        break;
+                    case '.':
+                        extensionIndex = i - 1;
+                        break;
+                }
+                c = name.charAt(i);
+            }
+
+            if (extensionIndex >= 0 && !EXECUTABLE_EXTENSIONS.contains(name.substring(extensionIndex).toLowerCase())) {
+                extensionIndex = -1;
+            }
+            
+            if (!executableOnly) {
+                if (isAbsolute) return name;
+            } else if (isPath) {
+                if (extensionIndex >= 0) return name;
+                
+                if (executableOnly) {
+                    return addExtension(name);
+                } else if (new File(name).exists()) {
+                    return name;
+                }
+
+                return null;
+            }
+
+            String[] paths = path.split(File.pathSeparator);
+            for (int p = 0; p < paths.length; p++) {
+                String currentPath = paths[p];
+                int currentPathLength = currentPath.length();
+                
+                if (currentPath == null || currentPathLength == 0) continue;
+                
+                if (currentPath.charAt(0) == '~' && 
+                    (currentPathLength == 1 || 
+                    (currentPathLength > 1 && (currentPath.charAt(1) == '/' || currentPath.charAt(1) == '\\')))) {
+                    String home = System.getenv("HOME");
+                    
+                    if (home != null) {
+                        currentPath = home + (currentPathLength == 1 ? "" : currentPath.substring(1));
+                    }
+                }
+                    
+                if (!currentPath.endsWith("/") && !currentPath.endsWith("\\")) {
+                    currentPath += "\\";
+                }
+                
+                String filename = currentPath + name;
+                if (Platform.IS_WINDOWS) filename = filename.replace('/', '\\');
+                
+                if (Platform.IS_WINDOWS && executableOnly && extensionIndex == -1) {
+                    String extendedFilename = addExtension(filename);
+                    
+                    if (extendedFilename != null) return extendedFilename;
+                    continue;
+                }
+
+                try {
+                    FileStat stat = posix.stat(filename);
+                    if (!executableOnly || (!stat.isDirectory() && stat.isExecutable())) return filename;
+                } catch (Throwable t) {}
+            }
+        }
+        
+        return null;
+    }
+    
+    public static String addExtension(String path) {
+        for (String extension : EXECUTABLE_EXTENSIONS) {
+            String newPath = path + extension;
+            
+            if (new File(newPath).exists()) return newPath;
+        }
+        
+        return null;
+    }
+}
diff --git a/src/main/java/jnr/posix/util/Java5ProcessMaker.java b/src/main/java/jnr/posix/util/Java5ProcessMaker.java
new file mode 100644
index 0000000..5f7f2c0
--- /dev/null
+++ b/src/main/java/jnr/posix/util/Java5ProcessMaker.java
@@ -0,0 +1,160 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+
+package jnr.posix.util;
+
+import jnr.posix.POSIXHandler;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+public class Java5ProcessMaker implements ProcessMaker {
+    private final ProcessBuilder builder;
+    private final POSIXHandler handler;
+
+    public Java5ProcessMaker(POSIXHandler handler, String... command) {
+        this.handler = handler;
+        builder = new ProcessBuilder(command);
+    }
+
+    public Java5ProcessMaker(POSIXHandler handler) {
+        this.handler = handler;
+        builder = new ProcessBuilder();
+    }
+
+    public List<String> command() {
+        return builder.command();
+    }
+
+    public ProcessMaker command(List<String> command) {
+        builder.command(command);
+        return this;
+    }
+
+    public ProcessMaker command(String... command) {
+        builder.command(command);
+        return this;
+    }
+
+    public File directory() {
+        return builder.directory();
+    }
+
+    public ProcessMaker directory(File dir) {
+        builder.directory(dir);
+        return this;
+    }
+
+    public Map<String, String> environment() {
+        return builder.environment();
+    }
+
+    public ProcessMaker environment(String[] envLines) {
+        envIntoProcessBuilder(builder, envLines);
+        return this;
+    }
+
+    public ProcessMaker inheritIO() {
+        handler.unimplementedError("inheritIO");
+        return this;
+    }
+
+    public Redirect redirectError() {
+        return Redirect.PIPE; // only option on Java 5/6
+    }
+
+    public ProcessMaker redirectError(File file) {
+        handler.unimplementedError("redirectError");
+        return this;
+    }
+
+    public ProcessMaker redirectError(Redirect destination) {
+        handler.unimplementedError("redirectError");
+        return this;
+    }
+
+    public boolean redirectErrorStream() {
+        return false;
+    }
+
+    public ProcessMaker redirectErrorStream(boolean redirectErrorStream) {
+        handler.unimplementedError("redirectErrorStream");
+        return this;
+    }
+
+    public Redirect redirectInput() {
+        return Redirect.PIPE; // only option on Java 5/6
+    }
+
+    public ProcessMaker redirectInput(File file) {
+        handler.unimplementedError("redirectInput");
+        return this;
+    }
+
+    public ProcessMaker redirectInput(Redirect source) {
+        handler.unimplementedError("redirectInput");
+        return this;
+    }
+
+    public Redirect redirectOutput() {
+        return Redirect.PIPE; // only option on Java 5/6
+    }
+
+    public ProcessMaker redirectOutput(File file) {
+        handler.unimplementedError("redirectOutput");
+        return this;
+    }
+
+    public ProcessMaker redirectOutput(Redirect destination) {
+        handler.unimplementedError("redirectOutput");
+        return this;
+    }
+
+    public Process start() throws IOException {
+        return builder.start();
+    }
+
+    private static void envIntoProcessBuilder(ProcessBuilder pb, String[] env) {
+        if (env == null) return;
+
+        pb.environment().clear();
+        for (String envLine : env) {
+            if (envLine.indexOf(0) != -1) {
+                envLine = envLine.replaceFirst("\u0000.*", "");
+            }
+
+            int index = envLine.indexOf('=');
+
+            if (index != -1) {
+                pb.environment().put(
+                        envLine.substring(0, index),
+                        envLine.substring(index + 1));
+            }
+        }
+    }
+}
diff --git a/src/main/java/jnr/posix/util/JavaCrypt.java b/src/main/java/jnr/posix/util/JavaCrypt.java
new file mode 100644
index 0000000..dc7f5c1
--- /dev/null
+++ b/src/main/java/jnr/posix/util/JavaCrypt.java
@@ -0,0 +1,232 @@
+package jnr.posix.util;
+
+public class JavaCrypt {
+    private static final int ITERATIONS = 16;
+    private static final int[] con_salt = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 0, 0, 0, 0, 0};
+    private static final boolean[] shifts2 = {false, false, true, true, true, true, true, true, false, true, true, true, true, true, true, false};
+    private static final int[][] skb = {{0, 16, 536870912, 536870928, 65536, 65552, 536936448, 536936464, 2048, 2064, 536872960, 536872976, 67584, 67600, 536938496, 536938512, 32, 48, 536870944, 536870960, 65568, 65584, 536936480, 536936496, 2080, 2096, 536872992, 536873008, 67616, 67632, 536938528, 536938544, 524288, 524304, 537395200, 537395216, 589824, 589840, 537460736, 537460752, 526336, 526352, 537397248, 537397264, 591872, 591888, 537462784, 537462800, 524320, 524336, 537395232, 537395248, 589856, 589872, 537460768, 537460784, 526368, 526384, 537397280, 537397296, 591904, 591920, 537462816, 537462832}, {0, 33554432, 8192, 33562624, 2097152, 35651584, 2105344, 35659776, 4, 33554436, 8196, 33562628, 2097156, 35651588, 2105348, 35659780, 1024, 33555456, 9216, 33563648, 2098176, 35652608, 2106368, 35660800, 1028, 33555460, 9220, 33563652, 2098180, 35652612, 2106372, 35660804, 268435456, 301989888, 268443648, 301998080, 270532608, 304087040, 270540800, 304095232, 268435460, 301989892, 268443652, 301998084, 270532612, 304087044, 270540804, 304095236, 268436480, 301990912, 268444672, 301999104, 270533632, 304088064, 270541824, 304096256, 268436484, 301990916, 268444676, 301999108, 270533636, 304088068, 270541828, 304096260}, {0, 1, 262144, 262145, 16777216, 16777217, 17039360, 17039361, 2, 3, 262146, 262147, 16777218, 16777219, 17039362, 17039363, 512, 513, 262656, 262657, 16777728, 16777729, 17039872, 17039873, 514, 515, 262658, 262659, 16777730, 16777731, 17039874, 17039875, 134217728, 134217729, 134479872, 134479873, 150994944, 150994945, 151257088, 151257089, 134217730, 134217731, 134479874, 134479875, 150994946, 150994947, 151257090, 151257091, 134218240, 134218241, 134480384, 134480385, 150995456, 150995457, 151257600, 151257601, 134218242, 134218243, 134480386, 134480387, 150995458, 150995459, 151257602, 151257603}, {0, 1048576, 256, 1048832, 8, 1048584, 264, 1048840, 4096, 1052672, 4352, 1052928, 4104, 1052680, 4360, 1052936, 67108864, 68157440, 67109120, 68157696, 67108872, 68157448, 67109128, 68157704, 67112960, 68161536, 67113216, 68161792, 67112968, 68161544, 67113224, 68161800, 131072, 1179648, 131328, 1179904, 131080, 1179656, 131336, 1179912, 135168, 1183744, 135424, 1184000, 135176, 1183752, 135432, 1184008, 67239936, 68288512, 67240192, 68288768, 67239944, 68288520, 67240200, 68288776, 67244032, 68292608, 67244288, 68292864, 67244040, 68292616, 67244296, 68292872}, {0, 268435456, 65536, 268500992, 4, 268435460, 65540, 268500996, 536870912, 805306368, 536936448, 805371904, 536870916, 805306372, 536936452, 805371908, 1048576, 269484032, 1114112, 269549568, 1048580, 269484036, 1114116, 269549572, 537919488, 806354944, 537985024, 806420480, 537919492, 806354948, 537985028, 806420484, 4096, 268439552, 69632, 268505088, 4100, 268439556, 69636, 268505092, 536875008, 805310464, 536940544, 805376000, 536875012, 805310468, 536940548, 805376004, 1052672, 269488128, 1118208, 269553664, 1052676, 269488132, 1118212, 269553668, 537923584, 806359040, 537989120, 806424576, 537923588, 806359044, 537989124, 806424580}, {0, 134217728, 8, 134217736, 1024, 134218752, 1032, 134218760, 131072, 134348800, 131080, 134348808, 132096, 134349824, 132104, 134349832, 1, 134217729, 9, 134217737, 1025, 134218753, 1033, 134218761, 131073, 134348801, 131081, 134348809, 132097, 134349825, 132105, 134349833, 33554432, 167772160, 33554440, 167772168, 33555456, 167773184, 33555464, 167773192, 33685504, 167903232, 33685512, 167903240, 33686528, 167904256, 33686536, 167904264, 33554433, 167772161, 33554441, 167772169, 33555457, 167773185, 33555465, 167773193, 33685505, 167903233, 33685513, 167903241, 33686529, 167904257, 33686537, 167904265}, {0, 256, 524288, 524544, 16777216, 16777472, 17301504, 17301760, 16, 272, 524304, 524560, 16777232, 16777488, 17301520, 17301776, 2097152, 2097408, 2621440, 2621696, 18874368, 18874624, 19398656, 19398912, 2097168, 2097424, 2621456, 2621712, 18874384, 18874640, 19398672, 19398928, 512, 768, 524800, 525056, 16777728, 16777984, 17302016, 17302272, 528, 784, 524816, 525072, 16777744, 16778000, 17302032, 17302288, 2097664, 2097920, 2621952, 2622208, 18874880, 18875136, 19399168, 19399424, 2097680, 2097936, 2621968, 2622224, 18874896, 18875152, 19399184, 19399440}, {0, 67108864, 262144, 67371008, 2, 67108866, 262146, 67371010, 8192, 67117056, 270336, 67379200, 8194, 67117058, 270338, 67379202, 32, 67108896, 262176, 67371040, 34, 67108898, 262178, 67371042, 8224, 67117088, 270368, 67379232, 8226, 67117090, 270370, 67379234, 2048, 67110912, 264192, 67373056, 2050, 67110914, 264194, 67373058, 10240, 67119104, 272384, 67381248, 10242, 67119106, 272386, 67381250, 2080, 67110944, 264224, 67373088, 2082, 67110946, 264226, 67373090, 10272, 67119136, 272416, 67381280, 10274, 67119138, 272418, 67381282}};
+    private static final int[][] SPtrans = {{8520192, 131072, -2139095040, -2138963456, 8388608, -2147352064, -2147352576, -2139095040, -2147352064, 8520192, 8519680, -2147483136, -2139094528, 8388608, 0, -2147352576, 131072, -2147483648, 8389120, 131584, -2138963456, 8519680, -2147483136, 8389120, -2147483648, 512, 131584, -2138963968, 512, -2139094528, -2138963968, 0, 0, -2138963456, 8389120, -2147352576, 8520192, 131072, -2147483136, 8389120, -2138963968, 512, 131584, -2139095040, -2147352064, -2147483648, -2139095040, 8519680, -2138963456, 131584, 8519680, -2139094528, 8388608, -2147483136, -2147352576, 0, 131072, 8388608, -2139094528, 8520192, -2147483648, -2138963968, 512, -2147352064}, {268705796, 0, 270336, 268697600, 268435460, 8196, 268443648, 270336, 8192, 268697604, 4, 268443648, 262148, 268705792, 268697600, 4, 262144, 268443652, 268697604, 8192, 270340, 268435456, 0, 262148, 268443652, 270340, 268705792, 268435460, 268435456, 262144, 8196, 268705796, 262148, 268705792, 268443648, 270340, 268705796, 262148, 268435460, 0, 268435456, 8196, 262144, 268697604, 8192, 268435456, 270340, 268443652, 268705792, 8192, 0, 268435460, 4, 268705796, 270336, 268697600, 268697604, 262144, 8196, 268443648, 268443652, 4, 268697600, 270336}, {1090519040, 16842816, 64, 1090519104, 1073807360, 16777216, 1090519104, 65600, 16777280, 65536, 16842752, 1073741824, 1090584640, 1073741888, 1073741824, 1090584576, 0, 1073807360, 16842816, 64, 1073741888, 1090584640, 65536, 1090519040, 1090584576, 16777280, 1073807424, 16842752, 65600, 0, 16777216, 1073807424, 16842816, 64, 1073741824, 65536, 1073741888, 1073807360, 16842752, 1090519104, 0, 16842816, 65600, 1090584576, 1073807360, 16777216, 1090584640, 1073741824, 1073807424, 1090519040, 16777216, 1090584640, 65536, 16777280, 1090519104, 65600, 16777280, 0, 1090584576, 1073741888, 1090519040, 1073807424, 64, 16842752}, {1049602, 67109888, 2, 68158466, 0, 68157440, 67109890, 1048578, 68158464, 67108866, 67108864, 1026, 67108866, 1049602, 1048576, 67108864, 68157442, 1049600, 1024, 2, 1049600, 67109890, 68157440, 1024, 1026, 0, 1048578, 68158464, 67109888, 68157442, 68158466, 1048576, 68157442, 1026, 1048576, 67108866, 1049600, 67109888, 2, 68157440, 67109890, 0, 1024, 1048578, 0, 68157442, 68158464, 1024, 67108864, 68158466, 1049602, 1048576, 68158466, 2, 67109888, 1049602, 1048578, 1049600, 68157440, 67109890, 1026, 67108864, 67108866, 68158464}, {33554432, 16384, 256, 33571080, 33570824, 33554688, 16648, 33570816, 16384, 8, 33554440, 16640, 33554696, 33570824, 33571072, 0, 16640, 33554432, 16392, 264, 33554688, 16648, 0, 33554440, 8, 33554696, 33571080, 16392, 33570816, 256, 264, 33571072, 33571072, 33554696, 16392, 33570816, 16384, 8, 33554440, 33554688, 33554432, 16640, 33571080, 0, 16648, 33554432, 256, 16392, 33554696, 256, 0, 33571080, 33570824, 33571072, 264, 16384, 16640, 33570824, 33554688, 264, 8, 16648, 33570816, 33554440}, {536870928, 524304, 0, 537397248, 524304, 2048, 536872976, 524288, 2064, 537397264, 526336, 536870912, 536872960, 536870928, 537395200, 526352, 524288, 536872976, 537395216, 0, 2048, 16, 537397248, 537395216, 537397264, 537395200, 536870912, 2064, 16, 526336, 526352, 536872960, 2064, 536870912, 536872960, 526352, 537397248, 524304, 0, 536872960, 536870912, 2048, 537395216, 524288, 524304, 537397264, 526336, 16, 537397264, 526336, 524288, 536872976, 536870928, 537395200, 526352, 0, 2048, 536870928, 536872976, 537397248, 537395200, 2064, 16, 537395216}, {4096, 128, 4194432, 4194305, 4198529, 4097, 4224, 0, 4194304, 4194433, 129, 4198400, 1, 4198528, 4198400, 129, 4194433, 4096, 4097, 4198529, 0, 4194432, 4194305, 4224, 4198401, 4225, 4198528, 1, 4225, 4198401, 128, 4194304, 4225, 4198400, 4198401, 129, 4096, 128, 4194304, 4198401, 4194433, 4225, 4224, 0, 128, 4194305, 1, 4194432, 0, 4194433, 4194432, 4224, 129, 4096, 4198529, 4194304, 4198528, 1, 4097, 4198529, 4194305, 4198528, 4198400, 4097}, {136314912, 136347648, 32800, 0, 134250496, 2097184, 136314880, 136347680, 32, 134217728, 2129920, 32800, 2129952, 134250528, 134217760, 136314880, 32768, 2129952, 2097184, 134250496, 136347680, 134217760, 0, 2129920, 134217728, 2097152, 134250528, 136314912, 2097152, 32768, 136347648, 32, 2097152, 32768, 134217760, 136347680, 32800, 134217728, 0, 2129920, 136314912, 134250528, 134250496, 2097184, 136347648, 32, 2097184, 134250496, 136347680, 2097152, 136314880, 134217760, 2129920, 32800, 134250528, 136314880, 32, 136347648, 2129952, 0, 134217728, 136314912, 32768, 2129952}};
+    private static final int[] cov_2char = {46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122};
+
+    private static final int byteToUnsigned(byte b) {
+        return b & 255;
+    }
+
+    private static int fourBytesToInt(byte[] b, int offset) {
+        int value;
+        value = byteToUnsigned(b[offset++]);
+        value |= (byteToUnsigned(b[offset++]) << 8);
+        value |= (byteToUnsigned(b[offset++]) << 16);
+        value |= (byteToUnsigned(b[offset++]) << 24);
+        return value;
+    }
+
+    private static final void intToFourBytes(int iValue, byte[] b, int offset) {
+        b[offset++] = (byte) ((iValue) & 255);
+        b[offset++] = (byte) ((iValue >>> 8) & 255);
+        b[offset++] = (byte) ((iValue >>> 16) & 255);
+        b[offset++] = (byte) ((iValue >>> 24) & 255);
+    }
+
+    private static final void PERM_OP(int a, int b, int n, int m, int[] results) {
+        int t;
+
+        t = ((a >>> n) ^ b) & m;
+        a ^= t << n;
+        b ^= t;
+
+        results[0] = a;
+        results[1] = b;
+    }
+
+    private static final int HPERM_OP(int a, int n, int m) {
+        int t;
+
+        t = ((a << (16 - n)) ^ a) & m;
+        a = a ^ t ^ (t >>> (16 - n));
+
+        return a;
+    }
+
+    private static int[] des_set_key(byte[] key) {
+        int[] schedule = new int[ITERATIONS * 2];
+
+        int c = fourBytesToInt(key, 0);
+        int d = fourBytesToInt(key, 4);
+
+        int[] results = new int[2];
+
+        PERM_OP(d, c, 4, 252645135, results);
+        d = results[0];
+        c = results[1];
+
+        c = HPERM_OP(c, -2, -859045888);
+        d = HPERM_OP(d, -2, -859045888);
+
+        PERM_OP(d, c, 1, 1431655765, results);
+        d = results[0];
+        c = results[1];
+
+        PERM_OP(c, d, 8, 16711935, results);
+        c = results[0];
+        d = results[1];
+
+        PERM_OP(d, c, 1, 1431655765, results);
+        d = results[0];
+        c = results[1];
+
+        d = (((d & 255) << 16) | (d & 65280) | ((d & 16711680) >>> 16) | ((c & -268435456) >>> 4));
+        c &= 268435455;
+
+        int s;
+        int t;
+        int j = 0;
+
+        for (int i = 0; i < ITERATIONS; i++) {
+            if (shifts2[i]) {
+                c = (c >>> 2) | (c << 26);
+                d = (d >>> 2) | (d << 26);
+            } else {
+                c = (c >>> 1) | (c << 27);
+                d = (d >>> 1) | (d << 27);
+            }
+
+            c &= 268435455;
+            d &= 268435455;
+
+            s = skb[0][(c) & 63] | skb[1][((c >>> 6) & 3) | ((c >>> 7) & 60)] | skb[2][((c >>> 13) & 15) | ((c >>> 14) & 48)] | skb[3][((c >>> 20) & 1) | ((c >>> 21) & 6) | ((c >>> 22) & 56)];
+
+            t = skb[4][(d) & 63] | skb[5][((d >>> 7) & 3) | ((d >>> 8) & 60)] | skb[6][(d >>> 15) & 63] | skb[7][((d >>> 21) & 15) | ((d >>> 22) & 48)];
+
+            schedule[j++] = ((t << 16) | (s & 65535)) & -1;
+            s = ((s >>> 16) | (t & -65536));
+
+            s = (s << 4) | (s >>> 28);
+            schedule[j++] = s & -1;
+        }
+        return schedule;
+    }
+
+    private static final int D_ENCRYPT(int L, int R, int S, int E0, int E1, int[] s) {
+        int t;
+        int u;
+        int v;
+
+        v = R ^ (R >>> 16);
+        u = v & E0;
+        v = v & E1;
+        u = (u ^ (u << 16)) ^ R ^ s[S];
+        t = (v ^ (v << 16)) ^ R ^ s[S + 1];
+        t = (t >>> 4) | (t << 28);
+
+        L ^= SPtrans[1][(t) & 63] | SPtrans[3][(t >>> 8) & 63] | SPtrans[5][(t >>> 16) & 63] | SPtrans[7][(t >>> 24) & 63] | SPtrans[0][(u) & 63] | SPtrans[2][(u >>> 8) & 63] | SPtrans[4][(u >>> 16) & 63] | SPtrans[6][(u >>> 24) & 63];
+
+        return L;
+    }
+
+    private static final int[] body(int[] schedule, int Eswap0, int Eswap1) {
+        int left = 0;
+        int right = 0;
+        int t = 0;
+
+        for (int j = 0; j < 25; j++) {
+            for (int i = 0; i < ITERATIONS * 2; i += 4) {
+                left = D_ENCRYPT(left, right, i, Eswap0, Eswap1, schedule);
+                right = D_ENCRYPT(right, left, i + 2, Eswap0, Eswap1, schedule);
+            }
+            t = left;
+            left = right;
+            right = t;
+        }
+
+        t = right;
+
+        right = (left >>> 1) | (left << 31);
+        left = (t >>> 1) | (t << 31);
+
+        left &= -1;
+        right &= -1;
+
+        int[] results = new int[2];
+
+        PERM_OP(right, left, 1, 1431655765, results);
+        right = results[0];
+        left = results[1];
+
+        PERM_OP(left, right, 8, 16711935, results);
+        left = results[0];
+        right = results[1];
+
+        PERM_OP(right, left, 2, 858993459, results);
+        right = results[0];
+        left = results[1];
+
+        PERM_OP(left, right, 16, 65535, results);
+        left = results[0];
+        right = results[1];
+
+        PERM_OP(right, left, 4, 252645135, results);
+        right = results[0];
+        left = results[1];
+
+        int[] out = new int[2];
+
+        out[0] = left;
+        out[1] = right;
+
+        return out;
+    }
+
+    public static final CharSequence crypt(CharSequence original, CharSequence salt) {
+        char[] buffer = new char[]{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '};
+
+        char charZero = salt.charAt(0);
+        char charOne = salt.charAt(1);
+
+        buffer[0] = charZero;
+        buffer[1] = charOne;
+
+        int Eswap0 = con_salt[charZero & 127];
+        int Eswap1 = con_salt[charOne & 127] << 4;
+
+        byte[] key = new byte[8];
+
+        for (int i = 0; i < key.length; i++) {
+            key[i] = (byte) 0;
+        }
+
+        for (int i = 0; i < key.length && i < original.length(); i++) {
+            int iChar = original.charAt(i) & 255;
+
+            key[i] = (byte) (iChar << 1);
+        }
+
+        int[] schedule = des_set_key(key);
+        int[] out = body(schedule, Eswap0, Eswap1);
+
+        byte[] b = new byte[9];
+
+        intToFourBytes(out[0], b, 0);
+        intToFourBytes(out[1], b, 4);
+        b[8] = 0;
+
+        for (int i = 2, y = 0, u = 128; i < 13; i++) {
+            for (int j = 0, c = 0; j < 6; j++) {
+                c <<= 1;
+
+                if (((int) b[y] & u) != 0) {
+                    c |= 1;
+                }
+
+                u >>>= 1;
+
+                if (u == 0) {
+                    y++;
+                    u = 128;
+                }
+                buffer[i] = (char) cov_2char[c];
+            }
+        }
+        return new String(buffer);
+    }
+}
diff --git a/src/main/java/jnr/posix/util/MethodName.java b/src/main/java/jnr/posix/util/MethodName.java
new file mode 100644
index 0000000..f993af6
--- /dev/null
+++ b/src/main/java/jnr/posix/util/MethodName.java
@@ -0,0 +1,25 @@
+package jnr.posix.util;
+
+public class MethodName {
+    private static final int CLIENT_CODE_STACK_INDEX;
+
+    static {
+        // Finds out the index of "this code" in the returned stack trace - funny but it differs in JDK 1.5 and 1.6
+        int i = 0;
+        for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
+            i++;
+            if (ste.getClassName().equals(MethodName.class.getName())) {
+                break;
+            }
+        }
+        CLIENT_CODE_STACK_INDEX = i;
+    }
+
+    public static String getMethodName() {
+        return Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX].getMethodName();
+    }
+
+    public static String getCallerMethodName() {
+        return Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX + 1].getMethodName();
+    }
+}
diff --git a/src/main/java/jnr/posix/util/Platform.java b/src/main/java/jnr/posix/util/Platform.java
new file mode 100644
index 0000000..e961a23
--- /dev/null
+++ b/src/main/java/jnr/posix/util/Platform.java
@@ -0,0 +1,128 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * 
+ *  
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+package jnr.posix.util;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Platform {
+    public static final String OS_NAME = System.getProperty("os.name");
+    public static final String OS_NAME_LC = OS_NAME.toLowerCase();
+
+    // Generic Windows designation
+    private static final String WINDOWS = "windows";
+    // For Windows 95, 98... Would these platforms actually work?
+    private static final String WINDOWS_9X = "windows 9";
+    // TODO: Windows ME?
+    private static final String WINDOWS_NT = "nt";
+    private static final String WINDOWS_20X = "windows 2";
+    private static final String WINDOWS_XP = "windows xp";
+    private static final String WINDOWS_SERVER = "server";
+    private static final String WINDOWS_VISTA = "vista";
+    private static final String WINDOWS_7 = "windows 7";
+    private static final String MAC_OS = "mac os";
+    private static final String DARWIN = "darwin";
+    private static final String FREEBSD = "freebsd";
+    private static final String DRAGONFLY = "dragonfly";
+    private static final String OPENBSD = "openbsd";
+    private static final String LINUX = "linux";
+    private static final String SOLARIS = "sunos";
+
+    // TODO: investigate supported platforms for OpenJDK7?
+
+    public static final boolean IS_WINDOWS = OS_NAME_LC.indexOf(WINDOWS) != -1;
+    public static final boolean IS_WINDOWS_9X = OS_NAME_LC.indexOf(WINDOWS_9X) > -1;
+    public static final boolean IS_WINDOWS_NT = IS_WINDOWS && OS_NAME_LC.indexOf(WINDOWS_NT) > -1;
+    public static final boolean IS_WINDOWS_20X = OS_NAME_LC.indexOf(WINDOWS_20X) > -1;
+    public static final boolean IS_WINDOWS_XP = OS_NAME_LC.indexOf(WINDOWS_XP) > -1;
+    public static final boolean IS_WINDOWS_VISTA = IS_WINDOWS && OS_NAME_LC.indexOf(WINDOWS_VISTA) > -1;
+    public static final boolean IS_WINDOWS_SERVER = IS_WINDOWS && OS_NAME_LC.indexOf(WINDOWS_SERVER) > -1;
+    public static final boolean IS_WINDOWS_7 = IS_WINDOWS && OS_NAME_LC.indexOf(WINDOWS_7) > -1;
+    public static final boolean IS_MAC = OS_NAME_LC.startsWith(MAC_OS) || OS_NAME_LC.startsWith(DARWIN);
+    public static final boolean IS_FREEBSD = OS_NAME_LC.startsWith(FREEBSD);
+    public static final boolean IS_DRAGONFLY = OS_NAME_LC.startsWith(DRAGONFLY);
+    public static final boolean IS_OPENBSD = OS_NAME_LC.startsWith(OPENBSD);
+    public static final boolean IS_LINUX = OS_NAME_LC.startsWith(LINUX);   
+    public static final boolean IS_SOLARIS = OS_NAME_LC.startsWith(SOLARIS);
+    public static final boolean IS_BSD = IS_MAC || IS_FREEBSD || IS_OPENBSD || IS_DRAGONFLY;
+    
+    public static final String envCommand() {
+        if (IS_WINDOWS) {
+            if (IS_WINDOWS_9X) {
+                return "command.com /c set";
+            } else if (IS_WINDOWS_NT || IS_WINDOWS_20X || IS_WINDOWS_XP ||
+                       IS_WINDOWS_SERVER || IS_WINDOWS_VISTA || IS_WINDOWS_7) {
+                return "cmd.exe /c set";
+            }
+        }
+        return "env";
+    }
+
+    public static final boolean IS_32_BIT = "32".equals(getProperty("sun.arch.data.model", "32"));
+    public static final boolean IS_64_BIT = "64".equals(getProperty("sun.arch.data.model", "64"));
+
+    public static final String ARCH;
+    static {
+        String arch = System.getProperty("os.arch");
+        if (arch.equals("amd64")) arch = "x86_64";
+        ARCH = arch;
+    }
+    
+    public static final Map<String, String> OS_NAMES = new HashMap<String, String>();
+    static {
+        OS_NAMES.put("Mac OS X", DARWIN);
+        OS_NAMES.put("Darwin", DARWIN);
+        OS_NAMES.put("Linux", LINUX);
+    }
+
+    public static String getOSName()  {
+        String theOSName = OS_NAMES.get(OS_NAME);
+        
+        return theOSName == null ? OS_NAME : theOSName;
+    }
+    
+    /**
+     * An extension over <code>System.getProperty</code> method.
+     * Handles security restrictions, and returns the default
+     * value if the access to the property is restricted.
+     * @param property The system property name.
+     * @param defValue The default value.
+     * @return The value of the system property,
+     *         or the default value.
+     */
+    public static String getProperty(String property, String defValue) {
+        try {
+            return System.getProperty(property, defValue);
+        } catch (SecurityException se) {
+            return defValue;
+        }
+    }
+}
diff --git a/src/main/java/jnr/posix/util/ProcessMaker.java b/src/main/java/jnr/posix/util/ProcessMaker.java
new file mode 100644
index 0000000..2dd5aac
--- /dev/null
+++ b/src/main/java/jnr/posix/util/ProcessMaker.java
@@ -0,0 +1,103 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+
+package jnr.posix.util;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Abstract interface for building a process on various JVM versions.
+ */
+public interface ProcessMaker {
+    public static class Redirect {
+        public static final Redirect INHERIT = new Redirect(Type.INHERIT);
+        public static final Redirect PIPE = new Redirect(Type.PIPE);
+
+        private enum Type {
+            APPEND,
+            INHERIT,
+            PIPE,
+            READ,
+            WRITE
+        }
+
+        private final Type type;
+        private final File file;
+
+        private Redirect(Type type) {
+            this(type, null);
+        }
+
+        private Redirect(Type type, File file) {
+            this.type = type;
+            this.file = file;
+        }
+
+        public static Redirect appendTo(File file) {
+            return new Redirect(Type.APPEND, file);
+        }
+
+        public static Redirect from(File file) {
+            return new Redirect(Type.READ, file);
+        }
+
+        public static Redirect to(File file) {
+            return new Redirect(Type.WRITE, file);
+        }
+
+        public File file() {
+            return file;
+        }
+
+        public Type type() {
+            return type;
+        }
+    }
+
+    public List<String> command();
+    public ProcessMaker command(List<String> command);
+    public ProcessMaker command(String... command);
+    public File directory();
+    public ProcessMaker directory(File dir);
+    public Map<String, String> environment();
+    public ProcessMaker environment(String[] envLines);
+    public ProcessMaker inheritIO();
+    public Redirect redirectError();
+    public ProcessMaker redirectError(File file);
+    public ProcessMaker redirectError(Redirect destination);
+    public boolean redirectErrorStream();
+    public ProcessMaker redirectErrorStream(boolean redirectErrorStream);
+    public Redirect redirectInput();
+    public ProcessMaker redirectInput(File file);
+    public ProcessMaker redirectInput(Redirect source);
+    public Redirect redirectOutput();
+    public ProcessMaker redirectOutput(File file);
+    public ProcessMaker redirectOutput(Redirect destination);
+    public Process start() throws IOException;
+}
diff --git a/src/main/java/jnr/posix/util/SunMiscSignal.java b/src/main/java/jnr/posix/util/SunMiscSignal.java
new file mode 100644
index 0000000..164a52e
--- /dev/null
+++ b/src/main/java/jnr/posix/util/SunMiscSignal.java
@@ -0,0 +1,36 @@
+package jnr.posix.util;
+
+import jnr.posix.SignalHandler;
+import sun.misc.Signal;
+
+public class SunMiscSignal {
+    public static SignalHandler signal(jnr.constants.platform.Signal sig, final SignalHandler handler) {
+        Signal s = new Signal(sig.name().substring("SIG".length()));
+
+        sun.misc.SignalHandler oldHandler = Signal.handle(s, new SunMiscSignalHandler(handler));
+
+        if (oldHandler instanceof SunMiscSignalHandler) {
+            return ((SunMiscSignalHandler)oldHandler).handler;
+        } else if (oldHandler != null) {
+            return new SignalHandler() {
+                @Override
+                public void handle(int signal) {
+                    oldHandler.handle(s);
+                }
+            };
+        } else {
+            return null;
+        }
+    }
+
+    private static class SunMiscSignalHandler implements sun.misc.SignalHandler {
+        final SignalHandler handler;
+        public SunMiscSignalHandler(SignalHandler handler) {
+            this.handler = handler;
+        }
+
+        public void handle(Signal signal) {
+            handler.handle(signal.getNumber());
+        }
+    }
+}
diff --git a/src/main/java/jnr/posix/util/WindowsHelpers.java b/src/main/java/jnr/posix/util/WindowsHelpers.java
new file mode 100644
index 0000000..705a111
--- /dev/null
+++ b/src/main/java/jnr/posix/util/WindowsHelpers.java
@@ -0,0 +1,422 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package jnr.posix.util;
+
+import jnr.ffi.*;
+
+import java.io.File;
+import java.io.UnsupportedEncodingException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.StringTokenizer;
+import jnr.posix.POSIX;
+
+/**
+ *
+ * @author enebo
+ */
+public class WindowsHelpers {
+    static final jnr.ffi.Runtime runtime = jnr.ffi.Runtime.getSystemRuntime();
+    static final int WORDSIZE = jnr.ffi.Runtime.getSystemRuntime().addressSize();
+    
+    public static byte[] toWPath(String path) {
+        return toWString(path);
+    }
+
+    public static byte[] toWString(String string) {
+        if (string == null) return null;
+        
+        string += (char) 0;
+
+        try {
+            return string.getBytes("UTF-16LE");
+        } catch (UnsupportedEncodingException e) {
+            return null; // JVM mandates this encoding. Not reached
+        }
+    }
+    
+    // FIXME: This does not work and I am unsure if it is because I am violating something
+    // CreateProcess requires OR because there are weird requirements in how env needs to be
+    // setup for CreateProcess (e.g. =C:=C:/ vars).
+    public static Pointer createWideEnv(String[] envp) {
+        if (envp == null) return null;
+        byte[] marker = {0};        
+        int envLength = envp.length;
+
+        // Allocate pointer for env pointer entries plus last \0\0 marker
+        Pointer result = Memory.allocateDirect(runtime, WORDSIZE * (envLength + 1));
+        
+        for (int i = 0; i < envLength; i++) {
+            byte[] bytes = toWString(envp[i]);
+            Pointer envElement = Memory.allocateDirect(runtime, bytes.length + 1);
+            envElement.put(0, bytes, 0, bytes.length);
+            envElement.put(bytes.length, marker, 0, marker.length);
+            result.putPointer(i * WORDSIZE, envElement);
+        }
+
+        Pointer nullMarker = Memory.allocateDirect(runtime, marker.length);
+        nullMarker.put(0, marker, 0, marker.length);
+        result.putPointer(WORDSIZE * envLength, nullMarker);
+
+        
+        return result;
+    }
+    // Windows cmd strings have various escaping:
+    // 1. <>|^ can all be escaped with ^ (e.g. ^<)
+    // 2. \s\t must be quoted if not already
+    // 3. Any arguments with double quotes must be escaped with a double 
+    //    quote around whole cmd    
+    private static void joinSingleArgv(StringBuilder buffer, String arg, 
+            boolean quote, boolean escape) {
+        int backslashCount = 0;
+        int start = 0;
+        
+        if (quote) buffer.append('"');
+        
+        for (int i = 0; i < arg.length(); i++) {
+            char c = arg.charAt(i);
+            switch(c) {
+                case '\\':
+                    backslashCount++;
+                    break;
+                case '"': {
+                    buffer.append(arg.substring(start, i));
+                    for (int j = 0; j < backslashCount + 1; j++) {
+                        buffer.append('\\');
+                    }
+                    backslashCount = 0;
+                    start = i;
+                }
+                case '<': case '>': case '|': case '^': {
+                    if (escape && !quote) {
+                        buffer.append(arg.substring(start, i));
+                        buffer.append('^');
+                        start = i;
+                        break;
+                    }
+                }
+                default: {
+                    backslashCount = 0;
+                    break;
+                }
+            }
+        }
+        buffer.append(arg.substring(start));
+        
+        if (quote) buffer.append('"');
+    }
+    
+    public static String joinArgv(String command, String[] argv, boolean escape) {
+        StringBuilder buffer = new StringBuilder();
+
+        if (command != null) {
+            buffer.append(command);
+            buffer.append(' ');
+        }
+
+        int last_index = argv.length - 1;
+        for (int i = 0; i <= last_index; i++) {
+            joinSingleArgv(buffer, argv[i], quotable(argv[i]), escape);
+            if (i != last_index) buffer.append(' '); // Add space between arguments
+        }
+        
+        return buffer.toString();
+    }    
+    
+    
+    public static boolean quotable(String value) {
+        if (value == null) return false;
+        StringTokenizer toker = new StringTokenizer(value, " \t\"'");
+        toker.nextToken(); // We know a string with no delimeters will return self
+        return toker.hasMoreTokens();
+    }
+    
+    public static boolean isBatch(String value) {
+        if (value == null) return false;
+        int length = value.length();
+        
+        if (length < 5) return false;
+        
+        String end = value.substring(length - 4);
+        
+        return end.equalsIgnoreCase(".bat") || end.equalsIgnoreCase(".cmd");
+    }
+    
+    public static String[] processCommandLine(POSIX posix, String command, 
+            String program, String path) {
+        String shell = null;
+        
+        if (program != null) {
+            String fullPath = Finder.findFileInPath(posix, program, path);
+            
+            shell = fullPath == null ? program : fullPath.replace('/', '\\');
+        } else {
+            // Strip off leading whitespace
+            command = command.substring(firstNonWhitespaceIndex(command));
+            
+            // FIXME: Ruby first looks for RUBYSHELL, but this only applies for
+            // JRuby (I doubt Jython wants to honor that env).  We need a generic
+            // hook for other envs to look for?
+            shell = System.getenv("COMSPEC");
+            boolean notHandledYet = true;
+            if (shell != null) {
+                boolean commandDotCom = isCommandDotCom(shell);
+                if (hasBuiltinSpecialNeeds(command) || isInternalCommand(command, commandDotCom)) {
+                    String quote = commandDotCom ? "\"" : "";
+                    command = shell + " /c " + quote + command + quote;
+                    notHandledYet = false;
+                }
+            }
+            
+            if (notHandledYet) {
+                char firstChar = command.charAt(0);
+                char quote = firstChar == '"' ? firstChar : (firstChar == '\'' ? firstChar : (char) 0);
+                int commandLength = command.length();
+
+                int i = quote == 0 ? 0 : 1;
+                
+                for(;; i++) {
+                    if (i == commandLength) {
+                        shell = command;
+                        break;
+                    }
+                    
+                    char c = command.charAt(i);
+                    
+                    if (c == quote) {
+                        shell = command.substring(1, i);
+                        break;
+                    }
+                    if (quote != 0) continue;
+                    
+                    if (Character.isSpaceChar(c) || isFunnyChar(c)) {
+                        shell = command.substring(0, i);
+                        break;
+                    }
+                }
+                shell = Finder.findFileInPath(posix, shell, path);
+                
+                if (shell == null) {
+                    shell = command.substring(0, i);
+                } else {
+                    if (!shell.contains(" ")) quote = 0;
+                    
+                    shell = shell.replace('/', '\\');
+                }
+            }                
+        }
+        
+        return new String[] { command, shell };
+    }
+
+    public static String[] processCommandArgs(POSIX posix, String program, 
+            String[] argv, String path) {
+           if (program == null || program.length() == 0) program = argv[0];
+        
+        boolean addSlashC = false;
+        boolean isNotBuiltin = false;
+        boolean notHandledYet = true;
+        String shell = System.getenv("COMSPEC");
+        String command = null;
+        if (shell != null) {
+            boolean commandDotCom = isCommandDotCom(shell);
+            if (isInternalCommand(program, commandDotCom)) {
+                isNotBuiltin = !commandDotCom;
+                program = shell;
+                addSlashC = true;
+                notHandledYet = false;
+            }
+        }
+        if (notHandledYet) {
+            command = Finder.findFileInPath(posix, program, path);
+            if (command != null) {
+                program = command.replace('/', '\\');
+            } else if (program.contains("/")) {
+                command = program.replace('/', '\\');
+                program = command;
+            }
+        }
+        
+        if (addSlashC || isBatch(program)) {
+            if (addSlashC) {
+                command = program + " /c ";
+            } else {
+                String[] newArgv = new String[argv.length - 1];
+                System.arraycopy(argv, 1, newArgv, 0, argv.length - 1);
+                argv = newArgv;
+            }
+
+            if (argv.length > 0) {
+                command = WindowsHelpers.joinArgv(command, argv, isNotBuiltin);
+            }
+            program = addSlashC ? shell : null;
+        } else {
+            command = WindowsHelpers.joinArgv(null, argv, false);
+        }
+        
+        return new String[] { command, program };
+    }
+    
+    private static boolean isFunnyChar(char c) {
+        return c == '<' || c == '>' || c == '|' || c == '*' || c == '?' ||
+                c == '"';
+    }
+
+    private static boolean hasBuiltinSpecialNeeds(String value) {
+        int length = value.length();
+        char quote = '\0';
+        
+        for (int i = 0; i < length; i++) {
+            char c = value.charAt(i);
+            switch (c) {
+                case '\'': case '\"':
+                    if (quote == '\0') {
+                        quote = c;
+                    } else if (quote == c) {
+                        quote = '\0';
+                    }
+                    break;
+                case '>': case '<': case '|': case '\n':
+                    if (quote != '\0') return true;
+                    break;
+                case '%':  // %FOO% check
+                    if (i + 1 < length) {
+                        i += 1;
+                        char c2 = value.charAt(i);
+                        if (c2 != ' ' && !Character.isLetter(c2)) break;
+                        for (int j = i; j < length; j++) {
+                            c2 = value.charAt(j);
+                            if (c2 != ' ' && !Character.isLetterOrDigit(c2)) break;
+                        }
+                        if (c2 == '%') return true;
+                    }
+                    break;
+            }
+	}
+        return false;
+    }
+    
+    private static int firstNonWhitespaceIndex(String value) {
+        int length = value.length();
+        int i = 0;
+        for (; i < length && Character.isSpaceChar(value.charAt(i)); i++) {}
+        return i;
+    }
+    
+    public static String escapePath(String path) {
+        StringBuilder buf = new StringBuilder();
+        
+        for (int i = 0; i < path.length(); i++) {
+            char c = path.charAt(i);
+            
+            buf.append(c);
+            if (c == '\\') buf.append(c);
+        }
+        return buf.toString() + "\\\\";
+    }    
+    
+    private final static String COMMAND_DOT_COM = "command.com";
+    private final static int CDC_LENGTH = COMMAND_DOT_COM.length();
+    private enum InternalType { SHELL, COMMAND, BOTH };
+    private static Map<String, InternalType> INTERNAL_COMMANDS = new HashMap<String, InternalType>() {{
+        put("assoc", InternalType.COMMAND);
+        put("break", InternalType.BOTH);
+        put("call", InternalType.BOTH);
+        put("cd", InternalType.BOTH);
+        put("chcp", InternalType.SHELL);
+        put("chdir", InternalType.BOTH);
+        put("cls", InternalType.BOTH);
+        put("color", InternalType.COMMAND);
+        put("copy", InternalType.BOTH);
+        put("ctty", InternalType.SHELL);
+        put("date", InternalType.BOTH);
+        put("del", InternalType.BOTH);
+        put("dir", InternalType.BOTH);
+        put("echo", InternalType.BOTH);
+        put("endlocal", InternalType.COMMAND);
+        put("erase", InternalType.BOTH);
+        put("exit", InternalType.BOTH);
+        put("for", InternalType.BOTH);
+        put("ftype", InternalType.COMMAND);
+        put("goto", InternalType.BOTH);
+        put("if", InternalType.BOTH);
+        put("lfnfor", InternalType.SHELL);
+        put("lh", InternalType.SHELL);
+        put("lock", InternalType.SHELL);
+        put("md", InternalType.BOTH);
+        put("mkdir", InternalType.BOTH);
+        put("move", InternalType.COMMAND);
+        put("path", InternalType.BOTH);
+        put("pause", InternalType.BOTH);
+        put("popd", InternalType.COMMAND);
+        put("prompt", InternalType.BOTH);
+        put("pushd", InternalType.COMMAND);
+        put("rd", InternalType.BOTH);
+        put("rem", InternalType.BOTH);
+        put("ren", InternalType.BOTH);
+        put("rename", InternalType.BOTH);
+        put("rmdir", InternalType.BOTH);
+        put("set", InternalType.BOTH);
+        put("setlocal", InternalType.COMMAND);
+        put("shift", InternalType.BOTH);
+        put("start", InternalType.COMMAND);
+        put("time", InternalType.BOTH);
+        put("title", InternalType.COMMAND);
+        put("truename", InternalType.SHELL);
+        put("type", InternalType.BOTH);
+        put("unlock", InternalType.SHELL);
+        put("ver", InternalType.BOTH);
+        put("verify", InternalType.BOTH);
+        put("vol", InternalType.BOTH);
+    }};
+    
+    private static boolean isDirectorySeparator(char value) {
+        return value == '/' || value == '\\';
+    }    
+    private static boolean isCommandDotCom(String command) {
+        int length = command.length();
+        int i = length - CDC_LENGTH;
+        
+        return i == 0 || i > 0 && isDirectorySeparator(command.charAt(i - 1)) &&
+                command.regionMatches(true, i, COMMAND_DOT_COM, 0, CDC_LENGTH);
+    }
+    
+    private static boolean isInternalCommand(String command, boolean hasCommandDotCom) {
+        assert command != null && !Character.isSpaceChar(command.charAt(0)) : "Spaces should have been stripped off already";
+        
+        int length = command.length();
+        
+        StringBuilder buf = new StringBuilder();
+        int i = 0;
+        char c = 0;
+        for (; i < length; i++) {
+            c = command.charAt(i);
+            if (!Character.isLetter(c)) break;
+            buf.append(Character.toLowerCase(c));
+        }
+        
+        if (i < length) {
+            if (c == '.' && i + 1 < length) i++;
+
+            switch (command.charAt(i)) {
+                case '<': case '>': case '|':
+                    return true;
+                case '\0': case ' ': case '\t': case '\n':
+                    break;
+                default:
+                    return false;
+            }
+        }
+
+        InternalType kindOf = INTERNAL_COMMANDS.get(buf.toString());
+        return kindOf == InternalType.BOTH || 
+                (hasCommandDotCom ? kindOf == InternalType.COMMAND : kindOf == InternalType.SHELL);
+    }
+
+    public static boolean isDriveLetterPath(String path) {
+        return path.length() >= 2 && Character.isLetter(path.charAt(0)) && path.charAt(1) == ':';
+    }
+        
+}
diff --git a/src/main/java/jnr/posix/windows/CommonFileInformation.java b/src/main/java/jnr/posix/windows/CommonFileInformation.java
new file mode 100644
index 0000000..9932163
--- /dev/null
+++ b/src/main/java/jnr/posix/windows/CommonFileInformation.java
@@ -0,0 +1,101 @@
+package jnr.posix.windows;
+
+import static jnr.posix.FileStat.*;
+
+/**
+ * Shared logic between by handle and file path FILE_INFORMATION.
+ */
+public abstract class CommonFileInformation extends jnr.ffi.Struct {
+    public static int FILE_ATTRIBUTE_READONLY  = 0x01;
+    public static int FILE_ATTRIBUTE_DIRECTORY = 0x10;
+
+    public class HackyFileTime {
+        private final UnsignedLong dwHighDateTime;
+        private final UnsignedLong dwLowDateTime;
+
+        public HackyFileTime(UnsignedLong high, UnsignedLong low) {
+            this.dwHighDateTime = high;
+            this.dwLowDateTime = low;
+        }
+
+        public long getLowDateTime() {
+            return dwLowDateTime.longValue();
+        }
+
+        public long getHighDateTime() {
+            return dwHighDateTime.longValue();
+        }
+
+        public long getLongValue() {
+            return (getHighDateTime() & 0xFFFFFFFFL) << 32 | (getLowDateTime() & 0xFFFFFFFFL);
+        }
+    }
+
+
+    protected CommonFileInformation(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+
+    public abstract int getFileAttributes();
+    public abstract HackyFileTime getCreationTime();
+    public abstract HackyFileTime getLastAccessTime();
+    public abstract HackyFileTime getLastWriteTime();
+    public abstract long getFileSizeHigh();
+    public abstract long getFileSizeLow();
+
+    public int getMode(java.lang.String path) {
+        int attr = getFileAttributes();
+        int mode = S_IRUSR;
+
+        if ((attr & FILE_ATTRIBUTE_READONLY) == 0) {
+            mode |= S_IWUSR;
+
+        }
+        mode |= (attr & FILE_ATTRIBUTE_DIRECTORY) != 0 ? (S_IFDIR | S_IXUSR) : S_IFREG;
+
+        path = path.toLowerCase();
+        if (path != null && (mode & S_IFREG) != 0 &&
+                (path.endsWith(".bat") || path.endsWith(".cmd") || path.endsWith(".com") || path.endsWith(".exe"))) {
+            mode |= S_IXUSR;
+        }
+
+        mode |= (mode & 0700) >> 3;
+        mode |= (mode & 0700) >> 6;
+
+        return mode;
+    }
+
+    public long getLastWriteTimeNanoseconds() {
+        return epochNanos(getLastWriteTime().getLongValue());
+    }
+
+    public long getLastAccessTimeNanoseconds() {
+        return epochNanos(getLastAccessTime().getLongValue());
+    }
+
+    public long getCreationTimeNanoseconds() {
+        return epochNanos(getCreationTime().getLongValue());
+    }
+
+    public long getFileSize() {
+        return (getFileSizeHigh() << 32) | getFileSizeLow();
+    }
+
+    // FIXME: I used same equation in C to get number.  I did something wrong with the math here in Java
+    //private static final int HOURS = 24;
+    //private static final int MINUTES = 60;
+    // private static final int SECONDS = 60;
+    public static final int NANOSECONDS = 1000 * 1000 * 1000;
+    // on number of days a year: https://imicrothinking.wordpress.com/tag/365-2425-days/
+    private static final double DAYS_BETWEEN_WINDOWS_AND_UNIX = (1970 - 1601) * 365.2425;
+    private static final long NANOSECONDS_TO_UNIX_EPOCH_FROM_WINDOWS = 11644473600L * NANOSECONDS;
+           // (long) (DAYS_BETWEEN_WINDOWS_AND_UNIX * HOURS * SECONDS * MINUTES * MICROSECONDS);
+
+    private long epochNanos(long windowsNanoChunks) {
+        return (windowsNanoChunks * 100) - NANOSECONDS_TO_UNIX_EPOCH_FROM_WINDOWS;
+    }
+
+    public static long asNanoSeconds(long seconds) {
+        return (seconds * 1000 + NANOSECONDS_TO_UNIX_EPOCH_FROM_WINDOWS / 1000) * 10;
+    }
+}
diff --git a/src/main/java/jnr/posix/windows/SystemTime.java b/src/main/java/jnr/posix/windows/SystemTime.java
new file mode 100644
index 0000000..2dfae63
--- /dev/null
+++ b/src/main/java/jnr/posix/windows/SystemTime.java
@@ -0,0 +1,25 @@
+package jnr.posix.windows;
+
+import jnr.ffi.*;
+
+/**
+ * Created by enebo on 9/18/2015.
+ */
+public class SystemTime extends jnr.ffi.Struct {
+    Unsigned16 wYear = new Unsigned16();
+    Unsigned16 wMonth = new Unsigned16();
+    Unsigned16 wDayOfWeek = new Unsigned16();
+    Unsigned16 wDay = new Unsigned16();
+    Unsigned16 wHour = new Unsigned16();
+    Unsigned16 wMinute = new Unsigned16();
+    Unsigned16 wSecond = new Unsigned16();
+    Unsigned16 wMilliseconds = new Unsigned16();
+    
+    public SystemTime(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+
+    public java.lang.String toString() {
+        return "" + wYear + "/" + wMonth + "/" + wDay + " " + wHour + ":" + wMinute + ":" + wSecond;
+    }
+}
diff --git a/src/main/java/jnr/posix/windows/WindowsByHandleFileInformation.java b/src/main/java/jnr/posix/windows/WindowsByHandleFileInformation.java
new file mode 100644
index 0000000..2b9b820
--- /dev/null
+++ b/src/main/java/jnr/posix/windows/WindowsByHandleFileInformation.java
@@ -0,0 +1,50 @@
+package jnr.posix.windows;
+
+/**
+ * BY_HANDLE_FILE_INFORMATION
+ */
+public class WindowsByHandleFileInformation extends CommonFileInformation {
+    final Unsigned32 dwFileAttributes = new Unsigned32();
+    // FIXME: I have no idea why I could not include FileTime here but having it do its own layout seems to change
+    // something.
+    final UnsignedLong chigh = new UnsignedLong();
+    final UnsignedLong clow = new UnsignedLong();
+    final UnsignedLong ahigh = new UnsignedLong();
+    final UnsignedLong alow = new UnsignedLong();
+    final UnsignedLong uhigh = new UnsignedLong();
+    final UnsignedLong ulow = new UnsignedLong();
+    final Unsigned32 dwVolumeSerialNumber = new Unsigned32();
+    final Unsigned32 nFileSizeHigh = new Unsigned32();
+    final Unsigned32 nFileSizeLow = new Unsigned32();
+    final Unsigned32 nNumberOfLinks = new Unsigned32();
+    final Unsigned32 nFileIndexHigh = new Unsigned32();
+    final Unsigned32 nFileIndexLow = new Unsigned32();
+
+    public WindowsByHandleFileInformation(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+
+    public HackyFileTime getCreationTime() {
+        return new HackyFileTime(chigh, clow);
+    }
+
+    public HackyFileTime getLastAccessTime() {
+        return new HackyFileTime(ahigh, alow);
+    }
+
+    public HackyFileTime getLastWriteTime() {
+        return new HackyFileTime(uhigh, ulow);
+    }
+
+    public int getFileAttributes() {
+        return dwFileAttributes.intValue();
+    }
+
+    public long getFileSizeHigh() {
+        return nFileSizeHigh.intValue();
+    }
+
+    public long getFileSizeLow() {
+        return nFileSizeLow.intValue();
+    }
+}
diff --git a/src/main/java/jnr/posix/windows/WindowsFileInformation.java b/src/main/java/jnr/posix/windows/WindowsFileInformation.java
new file mode 100644
index 0000000..d719e41
--- /dev/null
+++ b/src/main/java/jnr/posix/windows/WindowsFileInformation.java
@@ -0,0 +1,58 @@
+package jnr.posix.windows;
+
+/**
+ * WIN32_FILE_ATTRIBUTE_DATA
+ */
+
+public class WindowsFileInformation extends CommonFileInformation {
+
+    final UnsignedLong dwFileAttributes;
+    // FIXME: I have no idea why I could not include FileTime here but having it do its own layout seems to change
+    // something.
+    final UnsignedLong chigh;
+    final UnsignedLong clow;
+    final UnsignedLong ahigh;
+    final UnsignedLong alow;
+    final UnsignedLong uhigh;
+    final UnsignedLong ulow;
+    final UnsignedLong nFileSizeHigh;
+    final UnsignedLong nFileSizeLow;
+
+    public WindowsFileInformation(jnr.ffi.Runtime runtime) {
+        super(runtime);
+
+        dwFileAttributes = new UnsignedLong();
+        clow = new UnsignedLong();
+        chigh = new UnsignedLong();
+        alow = new UnsignedLong();
+        ahigh = new UnsignedLong();
+        ulow = new UnsignedLong();
+        uhigh = new UnsignedLong();
+        nFileSizeHigh = new UnsignedLong();
+        nFileSizeLow = new UnsignedLong();
+    }
+
+    public HackyFileTime getCreationTime() {
+        return new HackyFileTime(chigh, clow);
+    }
+
+    public HackyFileTime getLastAccessTime() {
+        return new HackyFileTime(ahigh, alow);
+    }
+
+    public HackyFileTime getLastWriteTime() {
+        return new HackyFileTime(uhigh, ulow);
+    }
+
+    public int getFileAttributes() {
+        return dwFileAttributes.intValue();
+    }
+
+    public long getFileSizeHigh() {
+        return nFileSizeHigh.longValue();
+    }
+
+    public long getFileSizeLow() {
+        return nFileSizeLow.longValue();
+    }
+}
diff --git a/src/main/java/jnr/posix/windows/WindowsFileTime.java b/src/main/java/jnr/posix/windows/WindowsFileTime.java
new file mode 100644
index 0000000..86b21d0
--- /dev/null
+++ b/src/main/java/jnr/posix/windows/WindowsFileTime.java
@@ -0,0 +1,25 @@
+package jnr.posix.windows;
+
+/**
+ * FILETIME
+ */
+public class WindowsFileTime extends jnr.ffi.Struct {
+    final Unsigned32 lowDateTime = new Unsigned32();
+    final Unsigned32 highDateTime = new Unsigned32();
+
+    public WindowsFileTime(jnr.ffi.Runtime runtime) {
+        super(runtime);
+    }
+
+    public int getLowDateTime() {
+        return lowDateTime.intValue();
+    }
+
+    public int getHighDateTime() {
+        return highDateTime.intValue();
+    }
+
+    public long getLongValue() {
+        return getHighDateTime() << 32 + getLowDateTime();
+    }
+}
diff --git a/src/main/java/jnr/posix/windows/WindowsFindData.java b/src/main/java/jnr/posix/windows/WindowsFindData.java
new file mode 100644
index 0000000..1a5de7a
--- /dev/null
+++ b/src/main/java/jnr/posix/windows/WindowsFindData.java
@@ -0,0 +1,77 @@
+package jnr.posix.windows;
+
+import jnr.ffi.*;
+
+/**
+ * WIN32_FIND_DATA.  For use with FindFirstFileW and friends (since this is for W methods
+ * the filename fields are wchar_t (or on windows usigned short) in width - TCHAR is an ambiguously
+ * sized type depending on which variant of method calls it).
+ */
+public class WindowsFindData extends CommonFileInformation {
+    public static final int MAX_PATH = 260;
+
+    final UnsignedLong dwFileAttributes;
+    // FIXME: I have no idea why I could not include FileTime here but having it do its own layout seems to change
+    // something.
+    final UnsignedLong chigh;
+    final UnsignedLong clow;
+    final UnsignedLong ahigh;
+    final UnsignedLong alow;
+    final UnsignedLong uhigh;
+    final UnsignedLong ulow;
+    final UnsignedLong nFileSizeHigh;
+    final UnsignedLong nFileSizeLow;
+    final UnsignedLong dwReserved0;
+    final UnsignedLong dwReserved1;
+    final Padding cFileName;
+    final Padding cAlternateFileName;
+
+    public WindowsFindData(jnr.ffi.Runtime runtime) {
+        super(runtime);
+
+        dwFileAttributes = new UnsignedLong();
+        clow = new UnsignedLong();
+        chigh = new UnsignedLong();
+        alow = new UnsignedLong();
+        ahigh = new UnsignedLong();
+        ulow = new UnsignedLong();
+        uhigh = new UnsignedLong();
+        nFileSizeHigh = new UnsignedLong();
+        nFileSizeLow = new UnsignedLong();
+        dwReserved0 = new UnsignedLong();
+        dwReserved1 = new UnsignedLong();
+        // This is epically large but any paths with //?/ can get a long name.  Also even if you do not
+        // and depend on MAX_PATH (original constant this struct is supposedly defined on) then you can
+        // get overflows from FindFirstFileW on reparse points.  So we will waste memory on allocation
+        // to avoid the potential for buffer overflows.
+        // This number specifically is the actual physical limit of a file size in NTFS.  So although this
+        // the functions using this struct cannot handle something this long the internet seems to think
+        // it is possible to get these long values copied into this field.
+        cFileName = new Padding(NativeType.USHORT, 32767);
+        cAlternateFileName = new Padding(NativeType.USHORT, 14);
+    }
+
+    public HackyFileTime getCreationTime() {
+        return new HackyFileTime(chigh, clow);
+    }
+
+    public HackyFileTime getLastAccessTime() {
+        return new HackyFileTime(ahigh, alow);
+    }
+
+    public HackyFileTime getLastWriteTime() {
+        return new HackyFileTime(uhigh, ulow);
+    }
+
+    public int getFileAttributes() {
+        return dwFileAttributes.intValue();
+    }
+
+    public long getFileSizeHigh() {
+        return nFileSizeHigh.longValue();
+    }
+
+    public long getFileSizeLow() {
+        return nFileSizeLow.longValue();
+    }
+}
diff --git a/src/test/java/jnr/posix/ConfstrTest.java b/src/test/java/jnr/posix/ConfstrTest.java
new file mode 100644
index 0000000..b616496
--- /dev/null
+++ b/src/test/java/jnr/posix/ConfstrTest.java
@@ -0,0 +1,34 @@
+package jnr.posix;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import java.nio.ByteBuffer;
+import jnr.constants.platform.Confstr;
+import jnr.constants.platform.Errno;
+import jnr.posix.util.Platform;
+
+public class ConfstrTest {
+    private static POSIX posix;
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+    }
+
+    @Test
+    public void confstr() {
+        if (Platform.IS_WINDOWS) {
+            int len = posix.confstr(Confstr._CS_PATH, null, 0);
+            assertEquals(-1, len);
+            assertEquals(Errno.EOPNOTSUPP.intValue(), posix.errno());
+        } else {
+            int len = posix.confstr(Confstr._CS_PATH, null, 0);
+            assertTrue("bad strlen", len > 0);
+
+            ByteBuffer buf = ByteBuffer.allocate(len);
+            posix.confstr(Confstr._CS_PATH, buf, len);
+            String str = new String(buf.array());
+            assertTrue("CS_PATH is blank", str.length() > 0);
+        }
+    }
+}
diff --git a/src/test/java/jnr/posix/CryptTest.java b/src/test/java/jnr/posix/CryptTest.java
new file mode 100644
index 0000000..f73c7b0
--- /dev/null
+++ b/src/test/java/jnr/posix/CryptTest.java
@@ -0,0 +1,40 @@
+package jnr.posix;
+
+import jnr.posix.util.Platform;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+/**
+ * Created by headius on 3/24/15.
+ */
+public class CryptTest {
+    @Before
+    public void before() {
+        posix = POSIXFactory.getPOSIX();
+    }
+    @Test
+    public void testCrypt() {
+        if (!Platform.IS_WINDOWS) {
+            String str1 = "blahblahblah";
+            String salt1 = "saltysalty";
+
+            CharSequence result1 = posix.crypt(str1, salt1);
+            Assert.assertNotNull(result1);
+
+            byte[] str1bytes = Arrays.copyOfRange(str1.getBytes(), 0, str1.length() + 1);
+            byte[] salt1bytes = Arrays.copyOfRange(salt1.getBytes(), 0, salt1.length() + 1);
+            byte[] result2 = posix.crypt(str1bytes, salt1bytes);
+
+            Assert.assertNotNull(result2);
+
+            String result2str = new String(result2, 0, result2.length - 1);
+
+            Assert.assertEquals(result1, result2str);
+        }
+    }
+
+    private POSIX posix;
+}
diff --git a/src/test/java/jnr/posix/DTableSizeTest.java b/src/test/java/jnr/posix/DTableSizeTest.java
new file mode 100644
index 0000000..7b05d27
--- /dev/null
+++ b/src/test/java/jnr/posix/DTableSizeTest.java
@@ -0,0 +1,22 @@
+package jnr.posix;
+
+import jnr.posix.util.Platform;
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.not;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assume.assumeTrue;
+
+public class DTableSizeTest {
+    @Test
+    public void testGetDtableSize() throws Exception
+    {
+        if (!Platform.IS_WINDOWS) { // FIXME: I have seen window's impl so this can be impld
+            POSIX posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+            assumeTrue("getdtablesize only supported on native posix", posix.isNative());
+
+            int dtablesize = posix.getdtablesize();
+            assertThat(dtablesize, not(-1));
+        }
+    }
+}
diff --git a/src/test/java/jnr/posix/DummyPOSIXHandler.java b/src/test/java/jnr/posix/DummyPOSIXHandler.java
new file mode 100644
index 0000000..737c915
--- /dev/null
+++ b/src/test/java/jnr/posix/DummyPOSIXHandler.java
@@ -0,0 +1,64 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package jnr.posix;
+
+import jnr.constants.platform.Errno;
+
+import java.io.File;
+import java.io.InputStream;
+import java.io.PrintStream;
+
+/**
+ *
+ * @author wayne
+ */
+public class DummyPOSIXHandler implements POSIXHandler {
+
+    public void error(Errno error, String extraData) {
+        throw new UnsupportedOperationException("error: " + error);
+    }
+    
+    public void error(Errno error, String methodName, String extraData) {
+        throw new UnsupportedOperationException("error: " + error);
+    }    
+
+    public void unimplementedError(String methodName) {
+        throw new UnsupportedOperationException("unimplemented method: " + methodName);
+    }
+
+    public void warn(WARNING_ID id, String message, Object... data) {
+        throw new UnsupportedOperationException("warning: " + id);
+    }
+
+    public boolean isVerbose() {
+        return true;
+    }
+
+    public File getCurrentWorkingDirectory() {
+        return new File("/tmp");
+    }
+
+    public String[] getEnv() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    public InputStream getInputStream() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    public PrintStream getOutputStream() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    public int getPID() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    public PrintStream getErrorStream() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+}
diff --git a/src/test/java/jnr/posix/EnvTest.java b/src/test/java/jnr/posix/EnvTest.java
new file mode 100644
index 0000000..47280c1
--- /dev/null
+++ b/src/test/java/jnr/posix/EnvTest.java
@@ -0,0 +1,83 @@
+package jnr.posix;
+
+import com.kenai.jffi.MemoryIO;
+import jnr.ffi.Pointer;
+import jnr.posix.util.Platform;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class EnvTest {
+    private static POSIX posix;
+
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+    }
+
+    @Test
+    public void testGetenv() throws Throwable {
+        assertNotNull(posix.getenv("PATH"));
+        assertNull(posix.getenv("SOME_NON_EXISTENT_ENV"));
+    }
+
+    @Test
+    public void testSetenvNonOverwrite() throws Throwable {
+        final String path = posix.getenv("PATH");
+        int result = posix.setenv("PATH", "new value", 0);
+
+        assertEquals(0, result);
+        assertEquals(path, posix.getenv("PATH"));
+    }
+
+    @Test
+    public void testSetenvOverwrite() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            final String path = posix.getenv("PATH");
+            int result = posix.setenv("PATH", "new value", 1);
+
+            assertEquals(0, result);
+            assertNotEquals(path, posix.getenv("PATH"));
+            posix.setenv("PATH", path, 1);
+        }
+    }
+
+    @Test
+    public void testSetEnvNewVar() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            int result = posix.setenv("MY_NEW_SETENV_VAR", "Yo", 0);
+
+            assertEquals(0, result);
+            assertEquals("Yo", posix.getenv("MY_NEW_SETENV_VAR"));
+        }
+    }
+
+    @Test
+    public void testUnsetenv() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            posix.setenv("MY_UNSETENV_VAR", "Yo", 1);
+            assertEquals("Yo", posix.getenv("MY_UNSETENV_VAR"));
+
+            int result = posix.unsetenv("MY_UNSETENV_VAR");
+            assertEquals(0, result);
+
+            assertNull(posix.getenv("MY_UNSETENV_VAR"));
+        }
+    }
+
+    @Test
+    public void testEnv() throws Throwable {
+        final Pointer env = posix.environ();
+
+        int offset = 0;
+        while (env.getPointer(offset) != null) {
+            final Pointer entryPointer = env.getPointer(offset);
+            final String entry = new String(MemoryIO.getInstance().getZeroTerminatedByteArray(entryPointer.address()));
+
+            assertTrue(entry.contains("="));
+
+            offset += jnr.ffi.Runtime.getSystemRuntime().addressSize();
+        }
+    }
+}
diff --git a/src/test/java/jnr/posix/FileStatTest.java b/src/test/java/jnr/posix/FileStatTest.java
new file mode 100644
index 0000000..3db2331
--- /dev/null
+++ b/src/test/java/jnr/posix/FileStatTest.java
@@ -0,0 +1,202 @@
+
+package jnr.posix;
+
+import java.io.FileOutputStream;
+import java.io.IOException;
+import jnr.posix.util.FieldAccess;
+import jnr.posix.util.Platform;
+import org.junit.*;
+
+import java.io.File;
+import java.io.FileDescriptor;
+import java.io.FileInputStream;
+import java.lang.reflect.Field;
+
+import static org.junit.Assert.*;
+
+public class FileStatTest {
+
+    public FileStatTest() {
+    }
+
+    private void addNBytes(File file, int amount) {
+        FileOutputStream fis = null;
+
+        try {
+            fis = new FileOutputStream(file);
+            byte[] buf = new byte[amount];
+            fis.write(buf);
+        } catch (IOException e) {
+            if (fis != null) { try { fis.close(); } catch (IOException e2) {} }
+        }
+    }
+
+    private static POSIX posix;
+
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+    }
+
+
+    @AfterClass
+    public static void tearDownClass() throws Exception {
+    }
+
+    @Before
+    public void setUp() {
+    }
+
+    @After
+    public void tearDown() {
+    }
+
+    @Test
+    public void filestat() throws Throwable {
+        File f = File.createTempFile("stat", null);
+        int size = 1567;
+        //Thread.sleep(2000);
+        addNBytes(f, size);
+        try {
+            FileStat stat = posix.stat(f.getAbsolutePath());
+            assertNotNull("posix.stat failed", stat);
+            assertEquals(size, stat.st_size());
+            assertEquals(1, stat.nlink());
+            //assertNotEquals(stat.mtime(), stat.ctime());
+
+            stat = posix.allocateStat();
+            int result = posix.stat(f.getAbsolutePath(), stat);
+            assertNotNull("posix.stat failed", stat);
+            assertEquals(0, result);
+            assertEquals(size, stat.st_size());
+        } finally {
+            f.delete();
+        }
+    }
+
+    @Test
+    public void filestatDescriptor() throws Throwable {
+        File f = File.createTempFile("stat", null);
+
+        try {
+            FileInputStream fis = new FileInputStream(f);
+            FileStat stat = posix.allocateStat();
+            int result = posix.fstat(fis.getFD(), stat);
+            assertEquals(0, result);
+            assertEquals(0, stat.st_size());
+        } finally {
+            f.delete();
+        }
+
+    }
+
+    @Test
+    public void filestatInt() throws Throwable {
+        // Windows does not store fd in FileDescriptor so this test wll not work
+        if (jnr.ffi.Platform.getNativePlatform().isUnix()) {
+            File f = File.createTempFile("stat", null);
+            try {
+                FileInputStream fis = new FileInputStream(f);
+                FileDescriptor desc = fis.getFD();
+                int fd = -1;
+                try {
+                    Field fdField = FieldAccess.getProtectedField(FileDescriptor.class, "fd");
+                    fd = fdField.getInt(desc);
+                } catch (SecurityException e) {
+                } catch (IllegalArgumentException e) {
+                } catch (IllegalAccessException e) {
+                }
+                FileStat stat = posix.allocateStat();
+                int result = posix.fstat(fd, stat);
+                assertTrue(fd > 2); // should not be stdin, stdout, stderr
+                assertEquals(0, result);
+            } finally {
+                f.delete();
+            }
+        } else {
+            FileStat stat = posix.fstat(0);
+            assertTrue(stat != null);
+        }
+    }
+
+    // FIXME: I could guarantee this does not exist but this was very very quick :)
+    private static final String NON_EXISTENT_FILENAME = "skdjlfklfsdjk";
+    @Test
+    public void filestatFailed() throws Throwable {
+        FileStat stat = null;
+
+        // A little wonky without adding a new posixhandler but we are using dummy so this is ok for now
+        // the default handler raises on a problem in stat so we are only verifying this at the moment.
+        try {
+            stat = posix.stat(NON_EXISTENT_FILENAME);
+        } catch (UnsupportedOperationException e) {}
+
+        assertTrue(stat == null);
+    }
+
+    
+    @Test
+    public void fileStatNanoTime() throws Throwable {
+        // Currently only linux file stat support nano time resolution
+        jnr.ffi.Platform nativePlatform = jnr.ffi.Platform.getNativePlatform();
+        if (nativePlatform.getOS() == jnr.ffi.Platform.OS.LINUX) {
+            File f = File.createTempFile("stat", null);
+            try {
+                FileStat st = posix.stat(f.getAbsolutePath());
+                assertNotNull("posix.stat failed", st);
+
+                FileStat stat = posix.allocateStat();
+                int result = posix.stat(f.getAbsolutePath(), stat);
+                assertNotNull("posix.stat failed", st);
+                assertEquals(0, result);
+
+                NanosecondFileStat fstat32 = (NanosecondFileStat) stat;
+                assertTrue(fstat32.cTimeNanoSecs() > 0);
+                assertTrue(fstat32.mTimeNanoSecs() > 0);
+                assertTrue(fstat32.aTimeNanoSecs() > 0);
+                assertEquals(fstat32.cTimeNanoSecs(), fstat32.mTimeNanoSecs());
+            } finally {
+                f.delete();
+            }
+        }
+    }
+
+    @Test
+    public void structStatSize() throws Throwable {
+        if (Platform.IS_SOLARIS) {
+            jnr.ffi.Runtime runtime = jnr.ffi.Runtime.getSystemRuntime();
+            if (Platform.IS_32_BIT) {
+                assertEquals("struct size is wrong", 144, new SolarisFileStat32.Layout(runtime).size());
+            } else {
+                assertEquals("struct size is wrong", 128, new SolarisFileStat64.Layout(runtime).size());
+            }
+        }
+
+        if (Platform.IS_SOLARIS) {
+            File f = File.createTempFile("stat", null);
+            try {
+                FileStat st = posix.stat(f.getAbsolutePath());
+
+                if (Platform.IS_32_BIT) {
+                    assertSame("incorrect stat instance returned", SolarisFileStat32.class, st.getClass());
+                } else {
+                    assertSame("incorrect stat instance returned", SolarisFileStat64.class, st.getClass());
+                }
+            } finally {
+                f.delete();
+            }
+        }
+    }
+
+    @Test
+    public void filestatDirectory() throws Throwable {
+        File f = File.createTempFile("stat", null).getParentFile();
+        try {
+            FileStat stat = posix.stat(f.getAbsolutePath());
+
+            assertTrue(stat.isDirectory());
+        } finally {
+            f.delete();
+        }
+    }
+}
diff --git a/src/test/java/jnr/posix/FileTest.java b/src/test/java/jnr/posix/FileTest.java
new file mode 100644
index 0000000..afadb07
--- /dev/null
+++ b/src/test/java/jnr/posix/FileTest.java
@@ -0,0 +1,680 @@
+package jnr.posix;
+
+import jnr.constants.platform.Access;
+import jnr.constants.platform.Fcntl;
+import jnr.constants.platform.Errno;
+import jnr.constants.platform.OpenFlags;
+import jnr.ffi.Pointer;
+import jnr.posix.util.Platform;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.*;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.charset.Charset;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+public class FileTest {
+    private static POSIX posix;
+
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+    }
+
+    @Test
+    public void utimesTest() throws Throwable {
+        // FIXME: On Windows this is working but providing wrong numbers and therefore getting wrong results.
+        if (!Platform.IS_WINDOWS) {
+            File f = File.createTempFile("utimes", null);
+
+            int rval = posix.utimes(f.getAbsolutePath(), new long[]{800, 200}, new long[]{900, 300});
+            assertEquals("utimes did not return 0", 0, rval);
+
+            FileStat stat = posix.stat(f.getAbsolutePath());
+
+            assertEquals("atime seconds failed", 800, stat.atime());
+            assertEquals("mtime seconds failed", 900, stat.mtime());
+
+            // The nano secs part is available in other stat implementations. We really just want to verify that the
+            // nsec portion of the timeval is passed through to the POSIX call.
+            // Mac seems to fail this test sporadically.
+            if (stat instanceof NanosecondFileStat && !Platform.IS_MAC) {
+                NanosecondFileStat linuxStat = (NanosecondFileStat) stat;
+
+                assertEquals("atime useconds failed", 200000, linuxStat.aTimeNanoSecs());
+                assertEquals("mtime useconds failed", 300000, linuxStat.mTimeNanoSecs());
+            }
+
+            f.delete();
+        }
+    }
+
+    @Test
+    public void utimesDefaultValuesTest() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            File f = File.createTempFile("utimes", null);
+
+            long oldTime = posix.stat(f.getAbsolutePath()).mtime();
+            Thread.sleep(2000);
+
+            int rval = posix.utimes(f.getAbsolutePath(), null, null);
+            assertEquals("utimes did not return 0", 0, rval);
+
+            FileStat stat = posix.stat(f.getAbsolutePath());
+
+            assertTrue("atime failed", stat.atime() > oldTime);
+            assertTrue("mtime failed", stat.mtime() > oldTime);
+
+            f.delete();
+        }
+    }
+
+    @Test
+    public void utimesPointerTest() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            File f = File.createTempFile("utimes", null);
+
+            Pointer times = jnr.ffi.Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8 * 4); // long[2][2] == 4 longs.
+            times.putLong(0, 800);
+            times.putLong(8, 200);
+            times.putLong(16, 900);
+            times.putLong(24, 300);
+
+            int rval = posix.utimes(f.getAbsolutePath(), times);
+            assertEquals("utimes did not return 0", 0, rval);
+
+            FileStat stat = posix.stat(f.getAbsolutePath());
+
+            assertEquals("atime seconds failed", 800, stat.atime());
+            assertEquals("mtime seconds failed", 900, stat.mtime());
+
+            // The nano secs part is available in other stat implementations.  We use Linux x86_64 because it's
+            // representative.  We really just want to verify that the usec portion of the timeval is passed throug
+            // to the POSIX call.
+            if (hasNanosecondPrecision(stat)) {
+                NanosecondFileStat linuxStat = (NanosecondFileStat) stat;
+
+//                assertEquals("atime useconds failed", 200000, linuxStat.aTimeNanoSecs());
+                assertEquals("mtime useconds failed", 300000, linuxStat.mTimeNanoSecs());
+            }
+
+            f.delete();
+        }
+    }
+
+    @Test
+    public void utimensatAbsolutePath() throws Throwable {
+        File file = File.createTempFile("utimensat", null);
+        utimensat(file, 0);
+    }
+
+    @Test
+    public void utimensatRelativePath() throws Throwable {
+        String path = "utimensat";
+        File file = new File(path);
+        file.createNewFile();
+        int parentFd = posix.open(".", OpenFlags.O_DIRECTORY.intValue(), 0444);
+        utimensat(file, parentFd);
+    }
+
+    @Test
+    public void futimens() throws Throwable {
+        File file = File.createTempFile("futimens", null);
+        FileStat fileStat = posix.stat(file.getPath());
+        if (!hasNanosecondPrecision(fileStat)) {
+            file.delete();
+            return;
+        }
+
+        long atimeSeconds = fileStat.atime()+1;
+        long mtimeSeconds = fileStat.mtime()-1;
+        long atimeNanoSeconds = 123456789;
+        long mtimeNanoSeconds = 135;
+        int fd = posix.open(file.getAbsolutePath(), OpenFlags.O_RDWR.intValue(), 0444);
+        posix.futimens(fd,
+                new long[] {atimeSeconds, atimeNanoSeconds},
+                new long[] {mtimeSeconds, mtimeNanoSeconds});
+        assertStatNanoSecond(file, atimeSeconds, atimeNanoSeconds, mtimeSeconds, mtimeNanoSeconds);
+    }
+
+    @Test
+    public void lutimesTest() throws Throwable {
+        // FIXME: On Windows this is working but providing wrong numbers and therefore getting wrong results.
+        if (!Platform.IS_WINDOWS) {
+            File f1 = File.createTempFile("lutimes", null);
+            File f2 = new File(f1.getParentFile(), "lutimes-link");
+            posix.symlink(f1.getAbsolutePath(), f2.getAbsolutePath());
+
+            int rval = posix.utimes(f1.getAbsolutePath(), new long[]{800, 0}, new long[]{900, 0});
+            assertEquals("utimes did not return 0", 0, rval);
+
+            rval = posix.lutimes(f2.getAbsolutePath(), new long[]{1800, 0}, new long[]{1900, 0});
+            assertEquals("lutimes did not return 0", 0, rval);
+
+            FileStat stat = posix.stat(f1.getAbsolutePath());
+            assertEquals("atime seconds failed", 800, stat.atime());
+            assertEquals("mtime seconds failed", 900, stat.mtime());
+
+            stat = posix.lstat(f2.getAbsolutePath());
+            assertEquals("atime seconds failed", 1800, stat.atime());
+            assertEquals("mtime seconds failed", 1900, stat.mtime());
+
+            f1.delete();
+            f2.delete();
+        }
+    }
+
+    @Test
+    public void futimeTest() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            File f = File.createTempFile("jnr-posix-futime", "tmp");
+            long oldTime = posix.stat(f.getAbsolutePath()).mtime();
+            Thread.sleep(2000);
+            int fd = posix.open(f.getAbsolutePath(), OpenFlags.O_RDWR.intValue(), 0666);
+            int rval = posix.futimes(fd, null, null);
+            assertEquals("futime did not return 0", 0, rval);
+            long newTime = posix.stat(f.getAbsolutePath()).mtime();
+            f.delete();
+            assertTrue("mtime failed", newTime > oldTime);
+        }
+    }
+
+    @Test
+    public void linkTest() throws Throwable {
+        File f1 = File.createTempFile("utime", null);
+        File f2 = new File(f1.getAbsolutePath() + "link");
+        int rval = posix.link(f1.getAbsolutePath(), f2.getAbsolutePath());
+        assertEquals("link did not return 0", 0, rval);
+        assertTrue("Link was not created", f2.exists());
+        f1.delete();
+        f2.delete();
+    }
+
+    @Test
+    public void mkdirRelativeTest() throws Throwable {
+        File dir = new File("tmp");
+        int rval = posix.mkdir(dir.getPath(), 0);
+        assertEquals("mkdir did not return 0", 0, rval);
+        assertTrue("Directory was not created", dir.exists());
+        dir.delete();
+    }
+
+    @Test
+    public void mkdirAbsoluteTest() throws Throwable {
+        File dir = new File("tmp");
+        int rval = posix.mkdir(dir.getAbsolutePath(), 0);
+        assertEquals("mkdir did not return 0", 0, rval);
+        assertTrue("Directory was not created", dir.exists());
+        dir.delete();
+    }
+    
+    @Test
+    public void flockTest() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            File tmp = File.createTempFile("flockTest", "tmp");
+            RandomAccessFile raf = new RandomAccessFile(tmp, "rw");
+            RandomAccessFile raf2 = new RandomAccessFile(tmp, "rw");
+            FileChannel fc = raf.getChannel();
+            FileChannel fc2 = raf2.getChannel();
+            FileDescriptor FD = JavaLibCHelper.getDescriptorFromChannel(fc);
+            FileDescriptor FD2 = JavaLibCHelper.getDescriptorFromChannel(fc2);
+            int fd = JavaLibCHelper.getfdFromDescriptor(FD);
+            int fd2 = JavaLibCHelper.getfdFromDescriptor(FD2);
+
+            assertEquals(0, posix.flock(fd, 1)); // LOCK_SH
+            assertEquals(0, posix.flock(fd, 8)); // LOCK_UN
+            assertEquals(0, posix.flock(fd, 2)); // LOCK_EX
+            assertEquals(-1, posix.flock(fd2, 2 | 4)); // LOCK_EX | LOCK_NB
+            assertEquals(0, posix.flock(fd, 8)); // LOCK_UN
+        }
+    }
+
+    @Test
+    public void dupTest() throws Throwable {
+        File tmp = File.createTempFile("dupTest", "tmp");
+        RandomAccessFile raf = new RandomAccessFile(tmp, "rw");
+        FileChannel fileChannel = raf.getChannel();
+        int fileDescriptor = getFdFromDescriptor(JavaLibCHelper.getDescriptorFromChannel(fileChannel));
+
+        byte[] outContent = "foo".getBytes();
+
+        FileDescriptor newFileDescriptor = toDescriptor(posix.dup(fileDescriptor));
+
+        new FileOutputStream(toDescriptor(fileDescriptor)).write(outContent);
+        raf.seek(0);
+
+        byte[] inContent = new byte[outContent.length];
+        new FileInputStream(newFileDescriptor).read(inContent, 0, 3);
+
+        assertArrayEquals(inContent, outContent);
+    }
+
+    public static final int SEEK_SET = 0;
+
+    @Test
+    public void dup2Test() throws Throwable {
+        File tmp = File.createTempFile("dupTest", "tmp");
+        int oldFd = posix.open(tmp.getAbsolutePath(), OpenFlags.O_RDWR.intValue(), 0666);
+        int newFd = 1000;
+
+        byte[] outContent = "foo".getBytes();
+
+        // NB: Windows differs a bit from POSIX's return value.  Both will return -1 on failure, but Windows will return
+        // 0 upon success, while POSIX will return the new FD.  Since we already know what the FD will be if the call
+        // is successful, it's easy to make code that works with both forms.  But it is something to watch out for.
+        assertNotEquals(-1, posix.dup2(oldFd, newFd));
+        FileDescriptor newFileDescriptor = toDescriptor(newFd);
+
+        new FileOutputStream(toDescriptor(oldFd)).write(outContent);
+        posix.lseek(newFd, SEEK_SET, 0);
+
+        byte[] inContent = new byte[outContent.length];
+        new FileInputStream(newFileDescriptor).read(inContent, 0, 3);
+
+        assertArrayEquals(inContent, outContent);
+    }
+
+    @Test
+    public void fcntlDupfdTest() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            File tmp = File.createTempFile("fcntlTest", "tmp");
+            int fd = posix.open(tmp.getPath(), OpenFlags.O_RDWR.intValue(), 0444);
+
+            byte[] outContent = "foo".getBytes();
+
+            // NOTE: This test used to call without the third argument, but this leads to undefined behavior.
+            // See https://github.com/jnr/jnr-posix/issues/144
+            int newFd = posix.fcntl(fd, Fcntl.F_DUPFD, 0);
+
+            new FileOutputStream(JavaLibCHelper.toFileDescriptor(fd)).write(outContent);
+            posix.lseek(fd, SEEK_SET, 0);
+
+            byte[] inContent = new byte[outContent.length];
+            new FileInputStream(JavaLibCHelper.toFileDescriptor(newFd)).read(inContent, 0, 3);
+
+            assertArrayEquals(inContent, outContent);
+        }
+    }
+
+    @Test
+    public void fcntlDupfdWithArgTest() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            File tmp = File.createTempFile("dupTest", "tmp");
+            int oldFd = JavaLibCHelper.getfdFromDescriptor(JavaLibCHelper.getDescriptorFromChannel(
+                    new RandomAccessFile(tmp, "rw").getChannel()));
+            int newFd = JavaLibCHelper.getfdFromDescriptor(JavaLibCHelper.getDescriptorFromChannel(
+                    new RandomAccessFile(tmp, "rw").getChannel()));
+
+            byte[] outContent = "foo".getBytes();
+
+            int expectedFd = 100;
+            int dupFd = posix.fcntl(oldFd, Fcntl.F_DUPFD, expectedFd);
+
+            new FileOutputStream(JavaLibCHelper.toFileDescriptor(newFd)).write(outContent);
+
+            byte[] inContent = new byte[outContent.length];
+            new FileInputStream(JavaLibCHelper.toFileDescriptor(dupFd)).read(inContent, 0, 3);
+
+            assertTrue(dupFd >= expectedFd);
+            assertArrayEquals(inContent, outContent);
+        }
+    }
+
+    @Test
+    public void closeTest() throws Throwable {
+        File tmp = File.createTempFile("closeTest", "tmp");
+        int fd = getFdFromDescriptor(JavaLibCHelper.getDescriptorFromChannel(new RandomAccessFile(tmp, "rw").getChannel()));
+
+        int result;
+
+        result = posix.close(fd);
+        assertEquals(0, result);
+
+        result = posix.close(fd);
+        assertEquals(-1, result);
+
+        // TODO (nirvdrum 06-May-15) We're not getting the correct errno value from Windows currently, so we need to skip this test.
+        if (!Platform.IS_WINDOWS) {
+            assertEquals(Errno.EBADF.intValue(), posix.errno());
+        }
+    }
+
+    @Test
+    public void unlinkTestNonWindows() throws Throwable {
+        if (! Platform.IS_WINDOWS) {
+            File tmp = File.createTempFile("unlinkTest", "tmp");
+            RandomAccessFile raf = new RandomAccessFile(tmp, "rw");
+
+            raf.write("hello".getBytes());
+
+            int res = posix.unlink(tmp.getCanonicalPath());
+
+            assertEquals(0, res);
+            assertFalse(tmp.exists());
+
+            raf.write("world".getBytes());
+            raf.seek(0);
+
+            byte[] actual = new byte[10];
+            raf.read(actual);
+
+            assertArrayEquals("helloworld".getBytes(), actual);
+        }
+    }
+
+    @Test
+    public void openTest() throws Throwable {
+        int fd = posix.open("pom.xml", 0, 0666);
+
+        assertNotEquals(-1, fd);
+
+        int result = posix.close(fd);
+        assertEquals(0, result);
+
+        result = posix.close(fd);
+        assertEquals(-1, result);
+
+        fd = posix.open("jnr-posix-filetest.txt", OpenFlags.O_CREAT.intValue() | OpenFlags.O_RDWR.intValue(), 0600);
+
+        assertEquals(0600, posix.stat("jnr-posix-filetest.txt").mode() & 0777);
+
+        result = posix.close(fd);
+        assertEquals(0, result);
+
+        new File("jnr-posix-filetest.txt").delete();
+    }
+
+    @Test
+    public void writeTest() throws Throwable {
+        String str = "To thine own self be true";
+        File tmp = File.createTempFile("writeTest", "tmp");
+        ByteBuffer buffer = ByteBuffer.wrap(str.getBytes());
+
+        int fd = posix.open(tmp.getAbsolutePath(), 1, 066);
+        posix.write(fd, buffer, str.length());
+        posix.close(fd);
+
+        RandomAccessFile raf = new RandomAccessFile(tmp, "rw");
+        assertEquals(raf.readLine(), new String(buffer.array()));
+        posix.unlink(tmp.getAbsolutePath());
+    }
+
+    @Test
+    public void pwriteTest() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            String str = "Now is the winter of our discontent";
+            File tmp = File.createTempFile("pwriteTest", "tmp");
+            RandomAccessFile raf = new RandomAccessFile(tmp, "rw");
+            raf.write(str.getBytes());
+            raf.close();
+
+            String str2 = "summer";
+            ByteBuffer buffer = ByteBuffer.wrap(str2.getBytes());
+
+            int fd = posix.open(tmp.getAbsolutePath(), 1, 066);
+            posix.pwrite(fd, buffer, str2.length(), 11);
+            posix.close(fd);
+
+            raf = new RandomAccessFile(tmp, "r");
+            assertEquals(raf.readLine(), "Now is the summer of our discontent");
+            posix.unlink(tmp.getAbsolutePath());
+        }
+    }
+
+    @Test
+    public void truncateTest() throws Throwable {
+        String str = "Beware the Jabberwock, my son!";
+        File tmp = File.createTempFile("truncateTest", "tmp");
+        RandomAccessFile raf = new RandomAccessFile(tmp, "rw");
+        raf.write(str.getBytes());
+        raf.close();
+
+        int shorterLength = str.length() - 10;
+        int longerLength = shorterLength * 2;
+
+        // Truncate should make a file shorter if the new length is less than the old length.
+        posix.truncate(tmp.getAbsolutePath(), shorterLength);
+        assertEquals(shorterLength, tmp.length());
+
+        // Truncate should extend a file if the new length is greater than the old length.
+        posix.truncate(tmp.getAbsolutePath(), longerLength);
+        assertEquals(longerLength, tmp.length());
+    }
+
+    @Test
+    public void ftruncateTest() throws Throwable {
+        String str = "Beware the Jabberwock, my son!";
+        File tmp = File.createTempFile("ftruncateTest", "tmp");
+        RandomAccessFile raf = new RandomAccessFile(tmp, "rw");
+        raf.write(str.getBytes());
+        raf.close();
+
+        int fd = posix.open(tmp.getAbsolutePath(), OpenFlags.O_RDWR.intValue(), 0666);
+        posix.ftruncate(fd, 21);
+        posix.lseekLong(fd, 0, 0);
+        byte[] buf = new byte[21];
+        int read = posix.read(fd, buf, 31);
+        assertEquals(21, read);
+        assertArrayEquals(buf, "Beware the Jabberwock".getBytes());
+    }
+
+    @Test
+    public void fcntlIntTest() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            int[] fds = new int[2];
+            int ret = posix.pipe(fds);
+            assertEquals(0, ret);
+            int flags = posix.fcntlInt(fds[0], Fcntl.F_GETFD, 0);
+            posix.fcntlInt(fds[0], Fcntl.F_SETFD, flags | 1); // FD_CLOEXEC
+            assertEquals(flags | 1, posix.fcntlInt(fds[0], Fcntl.F_GETFD, 0));
+        }
+    }
+
+    @Test
+    public void fchmodTest() throws IOException {
+        if (!Platform.IS_WINDOWS) {
+            File tmp = File.createTempFile("jnr-posix-chmod-test", "tmp");
+            int fd = posix.open(tmp.getAbsolutePath(), OpenFlags.O_RDWR.intValue(), 0600);
+
+            assertEquals("chmod: ", 0, posix.fchmod(fd, 0));
+            assertEquals("chmod: ", 0, posix.fchmod(fd, 0777));
+            tmp.delete();
+        }
+    }
+
+
+    @Test
+    public void renameTest() throws IOException {
+        File oldFile = File.createTempFile("jnr-posix-rename-test", "tmp");
+        File newFile = new File(oldFile.getParent() + File.separatorChar + "jnr-posix-rename-test-new");
+
+        assertTrue(oldFile.exists());
+        assertFalse(newFile.exists());
+
+        posix.rename(oldFile.getCanonicalPath(), newFile.getCanonicalPath());
+
+        assertFalse(oldFile.exists());
+        assertTrue(newFile.exists());
+
+        newFile.delete();
+    }
+
+    @Test
+    public void accessTest() throws IOException {
+        File tmp = File.createTempFile("jnr-posix-access-test", "tmp");
+
+        jnr.constants.platform.Access.F_OK.intValue();
+
+        // Set permissions to read-only and verify we don't have permissions to write.
+        String canonicalPath = tmp.getCanonicalPath();
+        assertEquals("chmod 0400: ", 0, posix.chmod(canonicalPath, 0400));
+        assertEquals("access " + canonicalPath + " for write: ", -1, posix.access(canonicalPath, Access.W_OK.intValue()));
+        assertEquals("access " + canonicalPath + " for read: ", 0, posix.access(canonicalPath, Access.R_OK.intValue()));
+
+        // Reset the permissions to read-write and verify we now have permissions to write.
+        assertEquals("chmod 0600: ", 0, posix.chmod(canonicalPath, 0600));
+        assertEquals("access " + canonicalPath + " for write: ", 0, posix.access(canonicalPath, Access.W_OK.intValue()));
+        assertEquals("access " + canonicalPath + " for read: ", 0, posix.access(canonicalPath, Access.R_OK.intValue()));
+
+        // F_OK just checks the file exists and should pass.
+        assertEquals("access " + canonicalPath + " exists: ", 0, posix.access(canonicalPath, Access.F_OK.intValue()));
+    }
+
+    @Test
+    public void readlinkTest() throws IOException {
+        if (!Platform.IS_WINDOWS) {
+            File file = File.createTempFile("jnr-pøsix-réådlînk-tést", "tmp");
+            File link = new File(file.getAbsolutePath() + "link");
+
+            posix.symlink(file.getAbsolutePath(), link.getAbsolutePath());
+
+            byte[] fileBytes = file.getAbsolutePath().getBytes();
+            int fileLength = fileBytes.length;
+
+            byte[] buffer = new byte[fileLength];
+
+            assertEquals(fileLength, posix.readlink(link.getAbsolutePath(), buffer, buffer.length));
+
+            assertArrayEquals(fileBytes, buffer);
+
+            link.delete();
+            file.delete();
+        }
+    }
+
+    @Test
+    public void readlinkByteBufferTest() throws IOException {
+        if (!Platform.IS_WINDOWS) {
+            File file = File.createTempFile("jnr-pøsix-réådlînk-tést", "tmp");
+            File link = new File(file.getAbsolutePath() + "link");
+
+            posix.symlink(file.getAbsolutePath(), link.getAbsolutePath());
+
+            byte[] fileBytes = file.getAbsolutePath().getBytes();
+            int fileLength = fileBytes.length;
+            ByteBuffer buffer = ByteBuffer.allocate(fileLength);
+
+            assertEquals(fileLength, posix.readlink(link.getAbsolutePath(), buffer, buffer.capacity()));
+
+            assertArrayEquals(buffer.array(), file.getAbsolutePath().getBytes());
+
+            link.delete();
+            file.delete();
+        }
+    }
+
+    @Test
+    public void readlinkPointerTest() throws IOException {
+        if (!Platform.IS_WINDOWS) {
+            File file = File.createTempFile("jnr-pøsix-réådlînk-tést", "tmp");
+            File link = new File(file.getAbsolutePath() + "link");
+
+            int bufSize = 1024;
+
+            Pointer buffer = jnr.ffi.Runtime.getSystemRuntime().getMemoryManager().allocateDirect(bufSize);
+
+            posix.symlink(file.getAbsolutePath(), link.getAbsolutePath());
+            
+            byte[] fileBytes = file.getAbsolutePath().getBytes();
+            int fileLength = fileBytes.length;
+
+            assertEquals(fileLength, posix.readlink(link.getAbsolutePath(), buffer, bufSize));
+
+            assertEquals(file.getAbsolutePath(), buffer.getString(0, fileLength, Charset.defaultCharset()));
+
+            link.delete();
+            file.delete();
+        }
+    }
+
+    @Test
+    public void mkfifoTest() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            File tmp = File.createTempFile("mkfifoTest", "tmp");
+            tmp.deleteOnExit();
+
+            int ret = posix.mkfifo(tmp.getAbsolutePath(), 0666);
+
+            FileInputStream fis = new FileInputStream(tmp);
+            FileOutputStream fos = new FileOutputStream(tmp);
+
+            byte[] content = "hello".getBytes();
+
+            fos.write(content);
+            fis.read(content);
+
+            assertArrayEquals("hello".getBytes(), content);
+        }
+    }
+
+    @Test
+    public void lseekTest() throws Throwable {
+        if (Platform.IS_MAC) {
+            int fd = posix.open("/dev/zero", 0, 0);
+
+            // use 2^33 to ensure we're out of int range
+            long offset = (long) Math.pow(2, 33);
+            long seek = posix.lseekLong(fd, offset, 0);
+
+            assertEquals(seek, offset);
+        }
+    }
+
+    private int getFdFromDescriptor(FileDescriptor descriptor) {
+        if (Platform.IS_WINDOWS) {
+            HANDLE handle = JavaLibCHelper.gethandle(descriptor);
+            return ((WindowsLibC) posix.libc())._open_osfhandle(handle, 0);
+        } else {
+            return JavaLibCHelper.getfdFromDescriptor(descriptor);
+        }
+    }
+
+    private FileDescriptor toDescriptor(int fd) {
+        if (Platform.IS_WINDOWS) {
+            HANDLE handle = ((WindowsLibC) posix.libc())._get_osfhandle(fd);
+            return JavaLibCHelper.toFileDescriptor(handle);
+        } else {
+            return JavaLibCHelper.toFileDescriptor(fd);
+        }
+    }
+
+    private boolean hasNanosecondPrecision(FileStat fileStat) {
+        return fileStat instanceof NanosecondFileStat && !Platform.IS_MAC;
+    }
+
+    private void utimensat(File file, int parentFd) {
+        String path = file.getAbsolutePath();
+        FileStat fileStat = posix.stat(path);
+        if (!hasNanosecondPrecision(fileStat)) {
+            file.delete();
+            return;
+        }
+
+        long atimeSeconds = fileStat.atime()+2;
+        long mtimeSeconds = fileStat.mtime()-2;
+        long atimeNanoSeconds = 123456789;
+        long mtimeNanoSeconds = 135;
+        posix.utimensat(parentFd,
+                path,
+                new long[] {atimeSeconds, atimeNanoSeconds},
+                new long[] {mtimeSeconds, mtimeNanoSeconds},
+                0);
+        assertStatNanoSecond(file, atimeSeconds, atimeNanoSeconds, mtimeSeconds, mtimeNanoSeconds);
+    }
+
+    private void assertStatNanoSecond(File file, long atimeSeconds, long atimeNanoSeconds, long mtimeSeconds, long mtimeNanoSeconds) {
+        NanosecondFileStat nanosecondFileStat = (NanosecondFileStat) posix.stat(file.getPath());
+        assertEquals("Access timestamp should be updated", atimeSeconds, nanosecondFileStat.atime());
+        assertEquals("Modification timestamp should be updated", mtimeSeconds, nanosecondFileStat.mtime());
+        assertEquals("Access time precision should be in ns", atimeNanoSeconds, nanosecondFileStat.aTimeNanoSecs());
+        assertEquals("Modification time precision should be in ns", mtimeNanoSeconds, nanosecondFileStat.mTimeNanoSecs());
+        file.delete();
+    }
+}
diff --git a/src/test/java/jnr/posix/GroupTest.java b/src/test/java/jnr/posix/GroupTest.java
new file mode 100644
index 0000000..6ede36a
--- /dev/null
+++ b/src/test/java/jnr/posix/GroupTest.java
@@ -0,0 +1,149 @@
+
+package jnr.posix;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import jnr.constants.platform.LangInfo;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ */
+public class GroupTest {
+
+    public GroupTest() {
+    }
+
+    private static POSIX posix;
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+    }
+
+    @AfterClass
+    public static void tearDownClass() throws Exception {
+    }
+
+    @Before
+    public void setUp() {
+    }
+
+    @After
+    public void tearDown() {
+    }
+
+    // TODO add test methods here.
+    // The methods must be annotated with annotation @Test. For example:
+    //
+    // @Test
+    // public void hello() {}
+    @Test
+    public void getgrnam() {
+        if (jnr.ffi.Platform.getNativePlatform().isUnix()) {
+            final String LOGIN = "daemon";
+            Group grp = posix.getgrnam(LOGIN);
+            assertNotNull(grp);
+            assertEquals("Login name not equal", LOGIN, grp.getName());
+        }
+    }
+
+    @Test
+    public void nonExistantGroupReturnsNull() {
+        if (jnr.ffi.Platform.getNativePlatform().isUnix()) {
+            final String LOGIN = "dkjhfjkdsfhjksdhfsdjkhfsdkjhfdskj";
+            assertNull("getpwnam for non-existant group should return null", posix.getgrnam(LOGIN));
+        }
+    }
+
+    @Test
+    public void getgrent() {
+        if (jnr.ffi.Platform.getNativePlatform().isUnix()) {
+            ArrayList<Group> grps = new ArrayList<Group>();
+            while (true) {
+                Group grp = posix.getgrent();
+                if (grp == null) {
+                    break;
+                }
+                grps.add(grp);
+            }
+            for (Group grp : grps) {
+                assertNotNull(grp.getName());
+                assertNotNull(grp.getPassword());
+                assertNotNull(grp.getGID());
+                for (String member : grp.getMembers()) {
+                    assertNotNull(member);
+                }
+            }
+        }
+    }
+
+    @Test
+    public void getgroups() throws Throwable {
+        if (jnr.ffi.Platform.getNativePlatform().isUnix()) {
+            String[] groupIdsAsStrings = exec("id", "-G").split(" ");
+            long[] expectedGroupIds = new long[groupIdsAsStrings.length];
+
+            for (int i = 0; i < groupIdsAsStrings.length; i++) {
+                expectedGroupIds[i] = Long.parseLong(groupIdsAsStrings[i]);
+            }
+
+            long[] actualGroupIds = posix.getgroups();
+
+            // getgroups does not specify whether the effective group ID is included along with the supplementary
+            // group IDs. However, `id -G` always includes all group IDs. So, we must do something of a fuzzy match.
+            // If the actual list is shorter than the expected list by 1, alter the expected list by removing the
+            // effective group ID before comparing the two arrays.
+            if (actualGroupIds.length == expectedGroupIds.length - 1) {
+                long effectiveGroupId = Long.parseLong(exec("id", "-g"));
+                expectedGroupIds = removeElement(expectedGroupIds, effectiveGroupId);
+            }
+
+            Arrays.sort(expectedGroupIds);
+            Arrays.sort(actualGroupIds);
+
+            assertArrayEquals(expectedGroupIds, actualGroupIds);
+        }
+    }
+
+    private String exec(String... command) throws IOException {
+        InputStreamReader isr = null;
+        BufferedReader reader = null;
+
+        try {
+            isr = new InputStreamReader(Runtime.getRuntime().exec(command).getInputStream());
+            reader = new BufferedReader(isr);
+
+            return reader.readLine();
+        } finally {
+            if (reader != null) {
+                reader.close();
+            }
+
+            if (isr != null) {
+                isr.close();
+            }
+        }
+    }
+
+    private long[] removeElement(long[] array, long value) {
+        for (int i = 0; i < array.length; i++) {
+            if (array[i] == value) {
+                long[] ret = new long[array.length - 1];
+                System.arraycopy(array, 0, ret, 0, i);
+                System.arraycopy(array, i + 1, ret, i, array.length - i - 1);
+                return ret;
+            }
+        }
+
+        return array;
+    }
+}
diff --git a/src/test/java/jnr/posix/HANDLETest.java b/src/test/java/jnr/posix/HANDLETest.java
new file mode 100644
index 0000000..eceeadd
--- /dev/null
+++ b/src/test/java/jnr/posix/HANDLETest.java
@@ -0,0 +1,57 @@
+package jnr.posix;
+
+import jnr.posix.util.Platform;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class HANDLETest {
+
+    private static POSIX posix;
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+    }
+
+    @Test
+    public void invalidHandleIsInValid() {
+        assertFalse(HANDLE.valueOf(-1L).isValid());
+    }
+
+    private static WindowsLibC kernel32() {
+        return (WindowsLibC) posix.libc();
+    }
+    
+    // This really is matching pipe for the sake of these unit tests but in general the 
+    // in/out/error handle will vary depending on how a CLI supplies it: 
+    // http://stackoverflow.com/questions/9021916/how-do-i-check-if-my-delphi-console-app-is-redirected-to-a-file-or-pipe
+    private boolean isValidHandleType(HANDLE handle) {
+        int type = kernel32().GetFileType(handle);
+        
+        return type == WindowsLibC.FILE_TYPE_DISK || type == WindowsLibC.FILE_TYPE_PIPE;
+    }
+
+    @Test
+    public void stdinHandle() {
+        if (Platform.IS_WINDOWS) {
+            assertTrue(kernel32().GetStdHandle(WindowsLibC.STD_INPUT_HANDLE).isValid());
+            assertTrue(isValidHandleType(kernel32().GetStdHandle(WindowsLibC.STD_INPUT_HANDLE)));
+        }
+    }
+
+    @Test
+    public void stdoutHandle() {
+        if (Platform.IS_WINDOWS) {
+            assertTrue(kernel32().GetStdHandle(WindowsLibC.STD_OUTPUT_HANDLE).isValid());
+            assertTrue(isValidHandleType(kernel32().GetStdHandle(WindowsLibC.STD_OUTPUT_HANDLE)));
+        }
+    }
+
+    @Test
+    public void stderrHandle() {
+        if (Platform.IS_WINDOWS) {
+            assertTrue(kernel32().GetStdHandle(WindowsLibC.STD_ERROR_HANDLE).isValid());
+            assertTrue(isValidHandleType(kernel32().GetStdHandle(WindowsLibC.STD_ERROR_HANDLE)));
+        }
+    }
+}
diff --git a/src/test/java/jnr/posix/HostnameTest.java b/src/test/java/jnr/posix/HostnameTest.java
new file mode 100644
index 0000000..cb094ce
--- /dev/null
+++ b/src/test/java/jnr/posix/HostnameTest.java
@@ -0,0 +1,47 @@
+package jnr.posix;
+
+import org.hamcrest.Matcher;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+import static org.junit.Assume.*;
+
+import java.io.IOException;
+import java.util.Scanner;
+
+public class HostnameTest {
+    private static POSIX posix;
+    private static POSIX jPosix;
+
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+        jPosix = POSIXFactory.getJavaPOSIX();
+    }
+
+    @Test
+    public void testHostnameWorks() {
+        assertNotNull(posix.gethostname());
+    }
+    
+    @Test
+    public void jPosixIsReasonable() {
+        // cast here works around a generic resolution problem in Java 11+
+        assumeThat(System.getenv().keySet(), (Matcher) anyOf(hasItem("HOSTNAME"), hasItem("COMPUTERNAME")));
+        assertNotNull(jPosix.gethostname());
+    }
+
+    @Test
+    public void testHostnameIsResonable() throws IOException {
+        String hostname = "";
+        try {
+            hostname = new Scanner(Runtime.getRuntime().exec("hostname").getInputStream()).next();
+        } catch (IOException e) {
+            assumeNoException(e);
+        }
+        assumeThat(hostname, is(not(equalTo(""))));
+        assertThat(posix.gethostname().toLowerCase(), equalTo(hostname.toLowerCase()));
+    }
+}
diff --git a/src/test/java/jnr/posix/IDTest.java b/src/test/java/jnr/posix/IDTest.java
new file mode 100644
index 0000000..c98c2e6
--- /dev/null
+++ b/src/test/java/jnr/posix/IDTest.java
@@ -0,0 +1,70 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+
+package jnr.posix;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class IDTest {
+
+    public IDTest() {
+    }
+    private static POSIX nativePosix, javaPosix;
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        nativePosix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+        javaPosix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), false);
+    }
+
+    @AfterClass
+    public static void tearDownClass() throws Exception {
+    }
+
+    @Before
+    public void setUp() {
+    }
+
+    @After
+    public void tearDown() {
+    }
+
+    @Test public void getuid() {
+        assertEquals("Java posix did not return same value as native posix", nativePosix.getuid(), javaPosix.getuid());
+    }
+    @Test public void getgid() {
+        assertEquals("Java posix did not return same value as native posix", nativePosix.getgid(), javaPosix.getgid());
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/jnr/posix/IOTest.java b/src/test/java/jnr/posix/IOTest.java
new file mode 100644
index 0000000..b0c0c98
--- /dev/null
+++ b/src/test/java/jnr/posix/IOTest.java
@@ -0,0 +1,231 @@
+package jnr.posix;
+
+import jnr.constants.platform.*;
+import jnr.posix.util.Platform;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.IntBuffer;
+
+/**
+ * Created by headius on 5/31/14.
+ */
+public class IOTest {
+    private static POSIX posix;
+
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+    }
+
+    @Test
+    public void testOpenReadWrite() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            File tmp = File.createTempFile("IOTest", "testOpen");
+            int fd = posix.open(tmp.getPath(), OpenFlags.O_RDWR.intValue(), 0666);
+            Assert.assertTrue(fd > 0);
+
+            byte[] hello = "hello".getBytes();
+            int written = posix.write(fd, hello, 5);
+            Assert.assertEquals(5, written);
+
+            byte[] buf = new byte[5];
+            posix.lseekLong(fd, 0, 0); // no jnr-constants for SEEK_SET
+            int read = posix.read(fd, buf, 5);
+            Assert.assertEquals(5, read);
+            Assert.assertArrayEquals(hello, buf);
+
+            byte[] goodbye = "goodbye".getBytes();
+            written = posix.pwrite(fd, goodbye, 7, 3);
+            Assert.assertEquals(7, written);
+            Assert.assertEquals(5, posix.lseekLong(fd, 0, 1)); // SEEK_CUR
+
+            byte[] bye = new byte[3];
+            read = posix.pread(fd, bye, 3, 7);
+            Assert.assertEquals(3, read);
+            Assert.assertEquals(5, posix.lseekLong(fd, 0, 1)); // SEEK_CUR
+            Assert.assertArrayEquals("bye".getBytes(), bye);
+        }
+    }
+
+    @Test
+    public void testPipe() throws Throwable {
+        int[] fds = {0, 0};
+        int ret = posix.pipe(fds);
+        Assert.assertTrue(ret >= 0);
+        Assert.assertTrue(fds[0] > 0);
+        Assert.assertTrue(fds[1] > 0);
+
+        byte[] hello = "hello".getBytes();
+        int written = posix.write(fds[1], hello, 5);
+        Assert.assertEquals(5, written);
+
+        byte[] buf = new byte[5];
+        int read = posix.read(fds[0], buf, 5);
+        Assert.assertEquals(5, read);
+        Assert.assertArrayEquals(buf, hello);
+    }
+
+    @Test
+    public void testPathconf() {
+        if (Platform.IS_WINDOWS) {
+            int res = posix.fpathconf(-1, Pathconf._PC_PIPE_BUF);
+            Assert.assertEquals(-1, res);
+            Assert.assertEquals(Errno.EOPNOTSUPP.intValue(), posix.errno());
+        } else {
+            int res = posix.fpathconf(-1, Pathconf._PC_PIPE_BUF);
+            Assert.assertEquals(-1, res);
+            
+            int[] fds = {0, 0};
+            posix.pipe(fds);
+            res = posix.fpathconf(fds[1], Pathconf._PC_PIPE_BUF);
+            if (Platform.IS_LINUX) {
+                Assert.assertEquals(4096, res);
+            } else {
+                Assert.assertTrue(res > 0);
+            }
+        }
+    }
+
+    @Test
+    public void testSocketPair() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            int[] fds = {0, 0};
+
+            int ret = posix.socketpair(AddressFamily.AF_UNIX.intValue(), Sock.SOCK_STREAM.intValue(), 0, fds);
+
+            Assert.assertTrue(ret >= 0);
+            Assert.assertTrue(fds[0] > 0);
+            Assert.assertTrue(fds[1] > 0);
+
+            byte[] hello = "hello".getBytes();
+            int written = posix.write(fds[1], hello, 5);
+            Assert.assertEquals(5, written);
+
+            byte[] buf = new byte[5];
+            int read = posix.read(fds[0], buf, 5);
+            Assert.assertEquals(5, read);
+            Assert.assertArrayEquals(buf, hello);
+
+            hello = "goodbye".getBytes();
+            written = posix.write(fds[0], hello, 7);
+            Assert.assertEquals(7, written);
+
+            buf = new byte[7];
+            read = posix.read(fds[1], buf, 7);
+            Assert.assertEquals(7, read);
+            Assert.assertArrayEquals(buf, hello);
+        }
+    }
+
+    @Test
+    public void testSendRecvMsg_NoControl() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            int[] fds = {0, 0};
+
+            int ret = posix.socketpair(AddressFamily.AF_UNIX.intValue(), Sock.SOCK_STREAM.intValue(), 0, fds);
+
+            Assert.assertTrue(ret >= 0);
+            Assert.assertTrue(fds[0] > 0);
+            Assert.assertTrue(fds[1] > 0);
+
+            MsgHdr outMessage = posix.allocateMsgHdr();
+
+            String data = "does this work?";
+            byte[] dataBytes = data.getBytes();
+
+            ByteBuffer[] outIov = new ByteBuffer[1];
+            outIov[0] = ByteBuffer.allocateDirect(dataBytes.length);
+            outIov[0].put(dataBytes);
+            outIov[0].flip();
+
+            outMessage.setIov(outIov);
+
+            int sendStatus = posix.sendmsg(fds[0], outMessage, 0);
+
+            Assert.assertTrue(sendStatus == dataBytes.length);
+
+            // ----------------
+
+            MsgHdr inMessage = posix.allocateMsgHdr();
+            ByteBuffer[] inIov = new ByteBuffer[1];
+            inIov[0] = ByteBuffer.allocateDirect(1024);
+            inMessage.setIov(inIov);
+
+            int recvStatus = posix.recvmsg(fds[1], inMessage, 0);
+
+            Assert.assertTrue(recvStatus == dataBytes.length);
+
+            for (int i = 0; i < recvStatus; ++i) {
+                Assert.assertEquals(dataBytes[i], outIov[0].get(i));
+            }
+        }
+    }
+
+    @Test
+    public void testSendRecvMsg_WithControl() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            int[] fds = {0, 0};
+
+            int ret = posix.socketpair(AddressFamily.AF_UNIX.intValue(), Sock.SOCK_STREAM.intValue(), 0, fds);
+
+            String data = "does this work?";
+            byte[] dataBytes = data.getBytes();
+
+
+            Assert.assertTrue(ret >= 0);
+            Assert.assertTrue(fds[0] > 0);
+            Assert.assertTrue(fds[1] > 0);
+
+            MsgHdr outMessage = posix.allocateMsgHdr();
+
+            ByteBuffer[] outIov = new ByteBuffer[1];
+            outIov[0] = ByteBuffer.allocateDirect(dataBytes.length);
+            outIov[0].put(dataBytes);
+            outIov[0].flip();
+
+            outMessage.setIov(outIov);
+
+            CmsgHdr outControl = outMessage.allocateControl(4);
+            outControl.setLevel(SocketLevel.SOL_SOCKET.intValue());
+            outControl.setType(0x01);
+
+            ByteBuffer fdBuf = ByteBuffer.allocateDirect(4);
+            fdBuf.order(ByteOrder.nativeOrder());
+            fdBuf.putInt(0, fds[0]);
+            outControl.setData(fdBuf);
+
+            int sendStatus = posix.sendmsg(fds[0], outMessage, 0);
+
+            Assert.assertTrue(sendStatus == dataBytes.length);
+
+            // ----------------
+
+            MsgHdr inMessage = posix.allocateMsgHdr();
+            ByteBuffer[] inIov = new ByteBuffer[1];
+            inIov[0] = ByteBuffer.allocateDirect(1024);
+            inMessage.setIov(inIov);
+
+            inMessage.allocateControl(4);
+            int recvStatus = posix.recvmsg(fds[1], inMessage, 0);
+
+            Assert.assertTrue(recvStatus == dataBytes.length);
+
+            ByteBuffer inFdBuf = inMessage.getControls()[0].getData();
+            inFdBuf.order(ByteOrder.nativeOrder());
+
+            int fd = inFdBuf.getInt();
+
+            Assert.assertTrue(fd != 0);
+
+            for (int i = 0; i < recvStatus; ++i) {
+                Assert.assertEquals(dataBytes[i], outIov[0].get(i));
+            }
+
+        }
+    }
+}
diff --git a/src/test/java/jnr/posix/JavaFileStatTest.java b/src/test/java/jnr/posix/JavaFileStatTest.java
new file mode 100644
index 0000000..88ebc05
--- /dev/null
+++ b/src/test/java/jnr/posix/JavaFileStatTest.java
@@ -0,0 +1,27 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package jnr.posix;
+
+import jnr.posix.JavaFileStat;
+import junit.framework.TestCase;
+
+import jnr.posix.util.Platform;
+
+/**
+ *
+ * @author nicksieger
+ */
+public class JavaFileStatTest extends TestCase {
+    public void testSetup() {
+        JavaFileStat fs = new JavaFileStat(null, null);
+        if (Platform.IS_WINDOWS) {
+            fs.setup("c:/");
+        } else {
+            fs.setup("/");
+        }
+        assertFalse(fs.isSymlink());
+    }
+}
diff --git a/src/test/java/jnr/posix/JavaPOSIXTest.java b/src/test/java/jnr/posix/JavaPOSIXTest.java
new file mode 100644
index 0000000..c5b93fd
--- /dev/null
+++ b/src/test/java/jnr/posix/JavaPOSIXTest.java
@@ -0,0 +1,119 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package jnr.posix;
+
+import java.io.File;
+import java.io.IOException;
+
+import jnr.constants.platform.Errno;
+import jnr.posix.JavaPOSIX;
+import jnr.posix.POSIX;
+import jnr.posix.Passwd;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ * @author wayne
+ */
+public class JavaPOSIXTest {
+    POSIX posix;
+    public JavaPOSIXTest() {
+    }
+
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+    }
+
+    @AfterClass
+    public static void tearDownClass() throws Exception {
+    }
+
+    @Before
+    public void setUp() {
+        posix = new JavaPOSIX(new DummyPOSIXHandler());
+    }
+
+    @After
+    public void tearDown() {
+        posix = null;
+    }
+
+    // TODO add test methods here.
+    // The methods must be annotated with annotation @Test. For example:
+    //
+    // @Test
+    // public void hello() {}
+    @Test public void uid() {
+        
+    }
+
+    @Test public void lstatTest() throws IOException {
+        File file = createTestFile();
+
+        FileStat stat = posix.lstat(file.getName());
+
+        assertTrue(stat.isEmpty());
+
+        stat = posix.allocateStat();
+        int ret = posix.lstat(file.getPath(), stat);
+
+        assertTrue(ret >= 0);
+        assertTrue(stat.isEmpty());
+
+        file.delete();
+
+        stat = posix.allocateStat();
+        ret = posix.lstat(file.getPath(), stat);
+
+        assertTrue(ret < 0);
+    }
+
+    @Test public void statMissingFileTest() throws IOException {
+        FileStat stat = posix.allocateStat();
+
+        int ret = posix.stat("does not exist", stat);
+
+        assertEquals(-1, ret);
+        assertEquals(Errno.ENOENT.intValue(), posix.errno());
+    }
+
+	@Test
+	public void chmodTest() throws IOException {
+        File file = createTestFile();
+
+		assertEquals("chmod: ", 0, posix.chmod(file.getName(), 0));
+		assertEquals("chmod: ", 0, posix.chmod(file.getName(), 0777));
+
+		file.delete();
+	}
+
+    @Test public void getpwuid() {
+        Passwd pwd = posix.getpwuid(posix.getuid());
+        assertNotNull("getpwuid failed", pwd);
+        
+    }
+    @Test public void isNative() {
+        assertFalse("JavaPOSIX isNative should be false", posix.isNative());
+    }
+
+    private File createTestFile() throws IOException {
+        // create a tmp file
+        String fName = "test.dat";
+        File file = new File(fName);
+        file.createNewFile();
+
+        return file;
+    }
+
+    @Test public void getpid() {
+        assertEquals(POSIXFactory.getNativePOSIX().getpid(), posix.getpid());
+    }
+}
diff --git a/src/test/java/jnr/posix/LinuxPOSIXTest.java b/src/test/java/jnr/posix/LinuxPOSIXTest.java
new file mode 100644
index 0000000..bdec625
--- /dev/null
+++ b/src/test/java/jnr/posix/LinuxPOSIXTest.java
@@ -0,0 +1,199 @@
+package jnr.posix;
+
+import jnr.constants.platform.AddressFamily;
+import jnr.constants.platform.PosixFadvise;
+import jnr.constants.platform.OpenFlags;
+import jnr.constants.platform.Sock;
+import jnr.constants.platform.SocketLevel;
+import jnr.constants.platform.SocketOption;
+import jnr.ffi.Platform;
+import jnr.posix.util.ConditionalTestRule;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.ClassRule;
+import org.junit.Test;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.io.File;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.RunnableFuture;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.locks.Lock;
+
+import static jnr.posix.LinuxIoPrio.*;
+
+public class LinuxPOSIXTest {
+
+    @ClassRule
+    public static RunningOnLinux rule = new RunningOnLinux();
+
+    private static Linux linuxPOSIX = null;
+
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        POSIX posix = POSIXFactory.getNativePOSIX();
+
+        if (posix instanceof Linux) {
+            linuxPOSIX = (Linux) posix;
+        }
+    }
+
+    /**
+     * Tests that IO priority can be set to a thread and that it doesn't change priority set on
+     * another thread
+     * @throws InterruptedException
+     * @throws ExecutionException
+     */
+    @Test
+    public void ioprioThreadedTest() throws InterruptedException, ExecutionException {
+        linuxPOSIX.ioprio_set(IOPRIO_WHO_PROCESS, 0, IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 4));
+
+        Future<Integer> threadPriorityFuture = Executors.newFixedThreadPool(1).submit(new Callable<Integer>() {
+            @Override
+            public Integer call() throws Exception {
+                linuxPOSIX.ioprio_set(IOPRIO_WHO_PROCESS, 0, IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 7));
+                return linuxPOSIX.ioprio_get(IOPRIO_WHO_PROCESS, 0);
+            }
+        });
+
+        int threadPriority = threadPriorityFuture.get().intValue();
+
+        Assert.assertEquals(7, IOPRIO_PRIO_DATA(threadPriority));
+        Assert.assertEquals(IOPRIO_CLASS_IDLE, IOPRIO_PRIO_CLASS(threadPriority));
+        Assert.assertEquals(4, IOPRIO_PRIO_DATA(linuxPOSIX.ioprio_get(IOPRIO_WHO_PROCESS, 0)));
+        Assert.assertEquals(IOPRIO_CLASS_BE, IOPRIO_PRIO_CLASS(linuxPOSIX.ioprio_get(IOPRIO_WHO_PROCESS, 0)));
+    }
+
+    @Test
+    public void testMessageHdrMultipleControl() {
+        if (jnr.posix.util.Platform.IS_WINDOWS) {
+            return;
+        }
+
+        int[] fds = {0, 0};
+
+        int ret = linuxPOSIX.socketpair(AddressFamily.AF_UNIX.intValue(),
+                Sock.SOCK_STREAM.intValue(),
+                0,
+                fds);
+
+
+        String data = "twoControlMessages";
+        byte[] dataBytes = data.getBytes();
+
+        Assert.assertTrue(ret >= 0);
+        Assert.assertTrue(fds[0] > 0);
+        Assert.assertTrue(fds[1] > 0);
+
+        ByteBuffer buf = ByteBuffer.allocate(4);
+        buf.order(ByteOrder.nativeOrder());
+        buf.putInt(1).flip();
+
+        ret = linuxPOSIX.libc().setsockopt(fds[1],
+                SocketLevel.SOL_SOCKET.intValue(),
+                SocketOption.SO_PASSCRED.intValue(),
+                buf,
+                buf.remaining());
+
+        Assert.assertTrue(ret >= 0);
+
+        MsgHdr outMessage = linuxPOSIX.allocateMsgHdr();
+
+        ByteBuffer[] outIov = new ByteBuffer[1];
+        outIov[0] = ByteBuffer.allocateDirect(dataBytes.length);
+        outIov[0].put(dataBytes);
+        outIov[0].flip();
+
+        outMessage.setIov(outIov);
+
+        CmsgHdr[] outControl = outMessage.allocateControls(new int[]{4});
+        outControl[0].setLevel(SocketLevel.SOL_SOCKET.intValue());
+        outControl[0].setType(0x01);
+
+        ByteBuffer fdBuf = ByteBuffer.allocateDirect(4);
+        fdBuf.order(ByteOrder.nativeOrder());
+        fdBuf.putInt(0, fds[0]);
+        outControl[0].setData(fdBuf);
+
+        int sendStatus = linuxPOSIX.sendmsg(fds[0], outMessage, 0);
+        if (sendStatus == -1) {
+            String sendmsgError = "Error with sendmsg: " + linuxPOSIX.strerror(linuxPOSIX.errno());
+            Assert.fail(sendmsgError);
+            return;
+        }
+
+        Assert.assertEquals(dataBytes.length, sendStatus);
+
+        // ----------------
+
+        MsgHdr inMessage = linuxPOSIX.allocateMsgHdr();
+        ByteBuffer[] inIov = new ByteBuffer[1];
+        inIov[0] = ByteBuffer.allocateDirect(1024);
+        inMessage.setIov(inIov);
+
+        inMessage.allocateControls(new int[]{4, 12});
+        int recvStatus = linuxPOSIX.recvmsg(fds[1], inMessage, 0);
+
+        Assert.assertEquals(dataBytes.length, recvStatus);
+
+        Assert.assertEquals(2, inMessage.getControls().length);
+
+        CmsgHdr[] controls = inMessage.getControls();
+        for (int x = 0; x < controls.length; x++) {
+            validateCmsghdr(controls[x]);
+        }
+    }
+
+    private void validateCmsghdr(CmsgHdr control) {
+        if (control.getLevel() == SocketLevel.SOL_SOCKET.intValue()
+                && control.getType() == 0x01) {
+            // Passing a FD
+            ByteBuffer inFdBuf = control.getData();
+            inFdBuf.order(ByteOrder.nativeOrder());
+
+            int fd = inFdBuf.getInt();
+
+            Assert.assertTrue(fd != 0);
+        } else if (control.getLevel() == SocketLevel.SOL_SOCKET.intValue()
+                && control.getType() == 0x02) {
+            //Credentials
+            ByteBuffer data = control.getData();
+            data.order(ByteOrder.nativeOrder());
+
+            int got_pid = data.getInt();
+            int got_uid = data.getInt();
+            int got_gid = data.getInt();
+
+            Assert.assertEquals(linuxPOSIX.getpid(), got_pid);
+            Assert.assertEquals(linuxPOSIX.getuid(), got_uid);
+            Assert.assertEquals(linuxPOSIX.getgid(), got_gid);
+        } else {
+            Assert.fail("Unable to determine cmsghdr type");
+        }
+    }
+
+    @Test
+    public void testPosixFadvise() throws Throwable {
+        File file = File.createTempFile("posix_fadvise", null);
+        int fd = linuxPOSIX.open(file.getAbsolutePath(), OpenFlags.O_RDWR.intValue(), 0444);
+
+        Assert.assertEquals(0, linuxPOSIX.posix_fadvise(fd, 0, 0, PosixFadvise.POSIX_FADV_SEQUENTIAL));
+        Assert.assertEquals(0, linuxPOSIX.posix_fadvise(fd, 0, 0, PosixFadvise.POSIX_FADV_RANDOM));
+        Assert.assertEquals(0, linuxPOSIX.posix_fadvise(fd, 0, 0, PosixFadvise.POSIX_FADV_NOREUSE));
+        Assert.assertEquals(0, linuxPOSIX.posix_fadvise(fd, 0, 0, PosixFadvise.POSIX_FADV_WILLNEED));
+        Assert.assertEquals(0, linuxPOSIX.posix_fadvise(fd, 0, 0, PosixFadvise.POSIX_FADV_DONTNEED));
+        Assert.assertEquals(0, linuxPOSIX.posix_fadvise(fd, 0, 0, PosixFadvise.POSIX_FADV_NORMAL)); // normal last to reset it
+
+        linuxPOSIX.close(fd);
+    }
+}
+
+class RunningOnLinux extends ConditionalTestRule {
+    public boolean isSatisfied() {
+        return jnr.ffi.Platform.getNativePlatform().getOS().equals(Platform.OS.LINUX);
+    }
+}
diff --git a/src/test/java/jnr/posix/NlLanginfoTest.java b/src/test/java/jnr/posix/NlLanginfoTest.java
new file mode 100644
index 0000000..2c13742
--- /dev/null
+++ b/src/test/java/jnr/posix/NlLanginfoTest.java
@@ -0,0 +1,45 @@
+package jnr.posix;
+
+import jnr.constants.platform.LangInfo;
+import jnr.posix.util.Platform;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+import static org.junit.Assert.assertEquals;
+
+public class NlLanginfoTest {
+    private static POSIX posix;
+
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+    }
+
+    @Test
+    public void testNlLanginfo() throws Throwable {
+        if (!Platform.IS_WINDOWS) {
+            InputStreamReader isr = null;
+            BufferedReader reader = null;
+
+            try {
+                isr = new InputStreamReader(Runtime.getRuntime().exec("locale charmap").getInputStream());
+                reader = new BufferedReader(isr);
+
+                String localeCharmap = reader.readLine();
+                assertEquals(localeCharmap, posix.nl_langinfo(LangInfo.CODESET.intValue()));
+            } finally {
+                if (reader != null) {
+                    reader.close();
+                }
+
+                if (isr != null) {
+                    isr.close();
+                }
+            }
+        }
+    }
+
+}
diff --git a/src/test/java/jnr/posix/POSIXFactoryTest.java b/src/test/java/jnr/posix/POSIXFactoryTest.java
new file mode 100644
index 0000000..c2ea3e7
--- /dev/null
+++ b/src/test/java/jnr/posix/POSIXFactoryTest.java
@@ -0,0 +1,20 @@
+package jnr.posix;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class POSIXFactoryTest {
+    @Test
+    public void testGetNativePOSIX() throws Throwable {
+        POSIX posix = POSIXFactory.getNativePOSIX();
+        assertTrue(posix.isNative());
+    }
+
+    @Test
+    public void testGetJavaPOSIX() throws Throwable {
+        POSIX posix = POSIXFactory.getJavaPOSIX();
+        assertFalse(posix.isNative());
+    }
+}
diff --git a/src/test/java/jnr/posix/PasswdTest.java b/src/test/java/jnr/posix/PasswdTest.java
new file mode 100644
index 0000000..623a7bf
--- /dev/null
+++ b/src/test/java/jnr/posix/PasswdTest.java
@@ -0,0 +1,69 @@
+
+package jnr.posix;
+
+import jnr.posix.util.Platform;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ */
+public class PasswdTest {
+
+    public PasswdTest() {
+    }
+    private static POSIX posix;
+    private static Class passwdClass;
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        if (Platform.IS_MAC) {
+            passwdClass = MacOSPasswd.class;
+        } else if (Platform.IS_LINUX) {
+            passwdClass = LinuxPasswd.class;
+        } else if (Platform.IS_FREEBSD) {
+            passwdClass = FreeBSDPasswd.class;
+        } else if (Platform.IS_OPENBSD) {
+            passwdClass = OpenBSDPasswd.class;
+        } else if (Platform.IS_SOLARIS) {
+            passwdClass = SolarisPasswd.class;
+        } else if (Platform.IS_WINDOWS) {
+            // Skipping these tests for windows
+        } else {
+            throw new IllegalArgumentException("Platform not supported");
+        }
+        posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+    }
+
+    @AfterClass
+    public static void tearDownClass() throws Exception {
+    }
+
+    @Before
+    public void setUp() {
+    }
+
+    @After
+    public void tearDown() {
+    }
+
+    @Test public void getpwnam() {
+        if (jnr.ffi.Platform.getNativePlatform().isUnix()) {
+            final String LOGIN = "root";
+            Passwd pwd = posix.getpwnam(LOGIN);
+            assertNotNull(pwd);
+            assertEquals("Login name not equal", LOGIN, pwd.getLoginName());
+
+            assertTrue(pwd.getClass().equals(passwdClass));
+        }
+    }
+    @Test public void nonExistantUserReturnsNull() {
+        if (jnr.ffi.Platform.getNativePlatform().isUnix()) {
+            final String LOGIN = "dkjhfjkdsfhjksdhfsdjkhfsdkjhfdskj";
+            assertNull("getpwnam for non-existant user should return null", posix.getpwnam(LOGIN));
+        }
+    }
+}
diff --git a/src/test/java/jnr/posix/ProcessTest.java b/src/test/java/jnr/posix/ProcessTest.java
new file mode 100644
index 0000000..35a588f
--- /dev/null
+++ b/src/test/java/jnr/posix/ProcessTest.java
@@ -0,0 +1,136 @@
+package jnr.posix;
+
+import jnr.posix.DefaultNativeRLimit;
+import jnr.posix.DummyPOSIXHandler;
+import jnr.posix.POSIX;
+import jnr.posix.POSIXFactory;
+import jnr.posix.RLimit;
+import jnr.posix.util.Platform;
+import jnr.constants.platform.RLIMIT;
+import jnr.constants.platform.Sysconf;
+import jnr.ffi.Pointer;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class ProcessTest {
+
+
+    private static POSIX posix;
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+    }
+
+    @Test
+    public void times() {
+        long hz = posix.sysconf(Sysconf._SC_CLK_TCK);
+        if (Platform.IS_MAC) {
+            assertEquals("incorrect HZ value", 100L, hz);
+        }
+    }
+
+    @Test
+    public void getcwd() {
+        String propCwd = System.getProperty("user.dir");
+        assertEquals(propCwd, posix.getcwd());
+    }
+
+    @Test
+    public void testGetRLimit() {
+        if (Platform.IS_LINUX) {
+            RLimit rlim = posix.getrlimit(RLIMIT.RLIMIT_NPROC.intValue());
+
+            // These tests may fail depending on how the system they're being run on is configured.  Since they are
+            // system-defined limits that may even differ based on UID, it's hard to find something universally true.
+            // Limiting the number of processes a user can create is believed to be universally enabled since without it
+            // the system would be susceptible to fork bombs.
+            assertTrue("Bad soft limit for number of processes", rlim.rlimCur() > 0);
+            assertTrue("Bad hard limit for number of processes", rlim.rlimMax() > 0);
+        }
+    }
+
+    @Test
+    public void testGetRLimitPreallocatedRlimit() {
+        if (Platform.IS_LINUX) {
+            RLimit rlim = new DefaultNativeRLimit(jnr.ffi.Runtime.getSystemRuntime());
+
+            int result = posix.getrlimit(RLIMIT.RLIMIT_NPROC.intValue(), rlim);
+            assertEquals("getrlimit did not return 0", 0, result);
+
+            // These tests may fail depending on how the system they're being run on is configured.  Since they are
+            // system-defined limits that may even differ based on UID, it's hard to find something universally true.
+            // Limiting the number of processes a user can create is believed to be universally enabled since without it
+            // the system would be susceptible to fork bombs.
+            assertTrue("Bad soft limit for number of processes", rlim.rlimCur() > 0);
+            assertTrue("Bad hard limit for number of processes", rlim.rlimMax() > 0);
+        }
+    }
+
+    @Test
+    public void testGetRLimitPointer() {
+        if (Platform.IS_LINUX) {
+            Pointer rlim = jnr.ffi.Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8 * 2); // 2 longs.
+
+            int result = posix.getrlimit(RLIMIT.RLIMIT_NPROC.intValue(), rlim);
+            assertEquals("getrlimit did not return 0", 0, result);
+
+            // These tests may fail depending on how the system they're being run on is configured.  Since they are
+            // system-defined limits that may even differ based on UID, it's hard to find something universally true.
+            // Limiting the number of processes a user can create is believed to be universally enabled since without it
+            // the system would be susceptible to fork bombs.
+            assertTrue("Bad soft limit for number of processes", rlim.getLong(0) > 0);
+            assertTrue("Bad hard limit for number of processes", rlim.getLong(8) > 0);
+        }
+    }
+
+    @Test
+    public void testSetRlimitLinux() {
+        if (Platform.IS_LINUX) {
+            RLimit originalRlim = posix.getrlimit(RLIMIT.RLIMIT_NPROC.intValue());
+
+            int result = posix.setrlimit(RLIMIT.RLIMIT_NPROC.intValue(), originalRlim.rlimCur() - 1, originalRlim.rlimMax() - 1);
+            assertEquals("setrlimit did not return 0", 0, result);
+
+            RLimit rlim = posix.getrlimit(RLIMIT.RLIMIT_NPROC.intValue());
+            assertEquals("soft limit didn't update", originalRlim.rlimCur() - 1, rlim.rlimCur());
+            assertEquals("hard limit didn't update", originalRlim.rlimMax() - 1, rlim.rlimMax());
+        }
+    }
+
+    @Test
+    public void testSetRlimitPreallocatedLinux() {
+        if (Platform.IS_LINUX) {
+            RLimit originalRlim = posix.getrlimit(RLIMIT.RLIMIT_NPROC.intValue());
+
+            RLimit updatedRlim = new DefaultNativeRLimit(jnr.ffi.Runtime.getSystemRuntime());
+            updatedRlim.init(originalRlim.rlimCur() - 1, originalRlim.rlimMax() - 1);
+
+            int result = posix.setrlimit(RLIMIT.RLIMIT_NPROC.intValue(), updatedRlim);
+            assertEquals("setrlimit did not return 0", 0, result);
+
+            RLimit rlim = posix.getrlimit(RLIMIT.RLIMIT_NPROC.intValue());
+            assertEquals("soft limit didn't update", originalRlim.rlimCur() - 1, rlim.rlimCur());
+            assertEquals("hard limit didn't update", originalRlim.rlimMax() - 1, rlim.rlimMax());
+        }
+    }
+
+    @Test
+    public void testSetRlimitPointerLinux() {
+        if (Platform.IS_LINUX) {
+            RLimit originalRlim = posix.getrlimit(RLIMIT.RLIMIT_NPROC.intValue());
+
+            Pointer updatedRlim = jnr.ffi.Runtime.getSystemRuntime().getMemoryManager().allocateDirect(8 * 2); // 2 longs.
+            updatedRlim.putLong(0, originalRlim.rlimCur() - 1);
+            updatedRlim.putLong(8, originalRlim.rlimMax() - 1);
+
+            int result = posix.setrlimit(RLIMIT.RLIMIT_NPROC.intValue(), updatedRlim);
+            assertEquals("setrlimit did not return 0", 0, result);
+
+            RLimit rlim = posix.getrlimit(RLIMIT.RLIMIT_NPROC.intValue());
+            assertEquals("soft limit didn't update", originalRlim.rlimCur() - 1, rlim.rlimCur());
+            assertEquals("hard limit didn't update", originalRlim.rlimMax() - 1, rlim.rlimMax());
+        }
+    }
+}
diff --git a/src/test/java/jnr/posix/SignalTest.java b/src/test/java/jnr/posix/SignalTest.java
new file mode 100644
index 0000000..01a8573
--- /dev/null
+++ b/src/test/java/jnr/posix/SignalTest.java
@@ -0,0 +1,70 @@
+package jnr.posix;
+
+import jnr.constants.platform.Signal;
+import jnr.posix.util.Platform;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class SignalTest {
+    private static POSIX posix;
+    private static POSIX javaPosix;
+    
+    @BeforeClass
+    public static void setupClass() throws Exception {
+        posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+        javaPosix = new JavaPOSIX(new DummyPOSIXHandler());
+    }
+    
+    private static void waitUntilTrue(AtomicBoolean var, long maxWait) {
+        long start = System.currentTimeMillis();
+        while (!var.get() && (System.currentTimeMillis() - start) < maxWait) {
+            try {
+                Thread.sleep(1);
+            } catch (InterruptedException e) {
+                break;
+            }
+        }
+    }
+    
+    @Test
+    public void testBasicSignal() {
+        if (!Platform.IS_WINDOWS) {
+            Signal s = Signal.SIGHUP;
+            final AtomicBoolean fired = new AtomicBoolean(false);
+            posix.signal(s, new SignalHandler() {
+                public void handle(int signal) {
+                    fired.set(true);
+                }
+            });
+
+            posix.kill(posix.getpid(), s.intValue());
+            waitUntilTrue(fired, 200);
+            Assert.assertTrue(fired.get());
+        }
+    }
+    
+    @Test
+    public void testJavaSignal() {
+        if (!Platform.IS_WINDOWS) {
+            Signal s = Signal.SIGHUP;
+            final AtomicBoolean fired = new AtomicBoolean(false);
+            SignalHandler previousHandler = javaPosix.signal(s, new SignalHandler() {
+                public void handle(int signal) {
+                    fired.set(true);
+                }
+            });
+
+            Assert.assertNotNull(previousHandler);
+
+            // have to use native here; no abstraction for kill in pure Java
+            // TODO: sun.misc.Signal.raise can be used to kill current pid
+            posix.kill(posix.getpid(), s.intValue());
+
+            waitUntilTrue(fired, 200);
+            Assert.assertTrue(fired.get());
+        }
+    }
+}
diff --git a/src/test/java/jnr/posix/SpawnTest.java b/src/test/java/jnr/posix/SpawnTest.java
new file mode 100644
index 0000000..b98a098
--- /dev/null
+++ b/src/test/java/jnr/posix/SpawnTest.java
@@ -0,0 +1,200 @@
+package jnr.posix;
+
+import jnr.constants.platform.windows.OpenFlags;
+import jnr.ffi.Library;
+import jnr.ffi.Platform;
+import jnr.ffi.annotations.Out;
+import org.junit.*;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.*;
+import static jnr.posix.SpawnFileAction.*;
+
+public class SpawnTest {
+    private static POSIX posix;
+    private static LibC libc;
+    private static final List<String> emptyEnv = Arrays.asList(new String[0]);
+    private static final List<SpawnFileAction> emptyActions = Arrays.asList(new SpawnFileAction[0]);
+
+    public static interface LibC {
+        int pipe(@Out int[] fds);
+    }
+
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        if (Platform.getNativePlatform().isUnix()) {
+            posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+            libc = Library.loadLibrary(LibC.class, jnr.ffi.Platform.getNativePlatform().getStandardCLibraryName());
+        }
+    }
+
+    @Test public void validPid() {
+        if (Platform.getNativePlatform().isUnix()) {
+            long pid = -1;
+            try {
+                pid = posix.posix_spawnp("true", emptyActions, Arrays.asList("true"), emptyEnv);
+                assertTrue(pid != -1);
+            } finally {
+                if (pid != -1) posix.libc().waitpid((int) pid, null, 0);
+            }
+        }
+    }
+
+    private static void closePipe(int[] fds) {
+        posix.libc().close(fds[0]);
+        posix.libc().close(fds[1]);
+    }
+
+    private static void killChild(long pid) {
+        if (pid > 0) {
+            posix.libc().kill((int) pid, 9); posix.libc().waitpid((int) pid, null, 0);
+        }
+    }
+
+    @Test public void outputPipe() {
+        if (Platform.getNativePlatform().isUnix()) {
+            int[] outputPipe = { -1, -1 };
+            long pid = -1;
+            try {
+                assertFalse(libc.pipe(outputPipe) < 0);
+                assertNotSame(-1, outputPipe[0]);
+                assertNotSame(-1, outputPipe[1]);
+
+                List<SpawnFileAction> actions = Arrays.asList(dup(outputPipe[1], 1));
+                pid = posix.posix_spawnp("echo", actions, Arrays.asList("echo", "bar"), emptyEnv);
+                assertTrue(pid != -1);
+
+                // close the write side of the output pipe, so read() will return immediately once the process has exited
+                posix.libc().close(outputPipe[1]);
+
+                ByteBuffer output = ByteBuffer.allocate(100);
+                long nbytes = posix.libc().read(outputPipe[0], output, output.remaining());
+                assertEquals(4L, nbytes);
+                output.position((int) nbytes).flip();
+                byte[] bytes = new byte[output.remaining()];
+                output.get(bytes);
+                assertEquals("bar", new String(bytes).trim());
+            } finally {
+                closePipe(outputPipe);
+                killChild(pid);
+            }
+        }
+    }
+
+    @Test public void inputPipe() {
+        if (Platform.getNativePlatform().isUnix()) {
+            int[] outputPipe = { -1, -1 };
+            int[] inputPipe = { -1, -1 };
+            long pid = -1;
+            try {
+            assertFalse(libc.pipe(outputPipe) < 0);
+                assertFalse(libc.pipe(inputPipe) < 0);
+                assertNotSame(-1, outputPipe[0]);
+                assertNotSame(-1, outputPipe[1]);
+                assertNotSame(-1, inputPipe[0]);
+                assertNotSame(-1, inputPipe[1]);
+
+                List<SpawnFileAction> actions = Arrays.asList(dup(inputPipe[0], 0), dup(outputPipe[1], 1));
+                pid = posix.posix_spawnp("cat", actions, Arrays.asList("cat", "-"), emptyEnv);
+                assertTrue(pid != -1);
+                posix.libc().close(inputPipe[0]);
+                assertEquals(3, posix.libc().write(inputPipe[1], ByteBuffer.wrap("foo".getBytes(Charset.forName("US-ASCII"))), 3));
+                posix.libc().close(inputPipe[1]); // send EOF to process
+
+                // close the write side of the output pipe, so read() will return immediately once the process has exited
+                posix.libc().close(outputPipe[1]);
+
+                ByteBuffer output = ByteBuffer.allocate(100);
+                long nbytes = posix.libc().read(outputPipe[0], output, output.remaining());
+                assertEquals(3L, nbytes);
+                output.position((int) nbytes).flip();
+                byte[] bytes = new byte[output.remaining()];
+                output.get(bytes);
+                assertEquals("foo", new String(bytes).trim());
+            } finally {
+                closePipe(outputPipe);
+                closePipe(inputPipe);
+                killChild(pid);
+            }
+        }
+    }
+
+    @Test public void inputFile() throws IOException {
+        if (Platform.getNativePlatform().isUnix()) {
+            File inputFile = File.createTempFile("foo", null);
+            FileOutputStream inputStream = new FileOutputStream(inputFile);
+            inputStream.write("foo".getBytes("US-ASCII"));
+            inputStream.close();
+            int[] outputPipe = { -1, -1 };
+            long pid = -1;
+            try {
+                assertFalse(libc.pipe(outputPipe) < 0);
+                assertNotSame(-1, outputPipe[0]);
+                assertNotSame(-1, outputPipe[1]);
+
+                List<SpawnFileAction> actions = Arrays.asList(open(inputFile.getAbsolutePath(), 0, OpenFlags.O_RDONLY.intValue(), 0444),
+                        dup(outputPipe[1], 1), close(outputPipe[0]));
+                pid = posix.posix_spawnp("cat", actions, Arrays.asList("cat", "-"), emptyEnv);
+                assertTrue(pid != -1);
+
+                // close the write side of the output pipe, so read() will return immediately once the process has exited
+                posix.libc().close(outputPipe[1]);
+
+                ByteBuffer output = ByteBuffer.allocate(100);
+                long nbytes = posix.libc().read(outputPipe[0], output, output.remaining());
+                assertEquals(3L, nbytes);
+                output.position((int) nbytes).flip();
+                byte[] bytes = new byte[output.remaining()];
+                output.get(bytes);
+                assertEquals("foo", new String(bytes).trim());
+            } finally {
+                closePipe(outputPipe);
+                killChild(pid);
+            }
+        }
+    }
+
+    @Test public void closeInput() throws IOException {
+        if (Platform.getNativePlatform().isUnix()) {
+            int[] outputPipe = { -1, -1 };
+            int[] inputPipe = { -1, -1 };
+            long pid = -1;
+            try {
+                assertFalse(libc.pipe(outputPipe) < 0);
+                assertFalse(libc.pipe(inputPipe) < 0);
+                assertNotSame(-1, outputPipe[0]);
+                assertNotSame(-1, outputPipe[1]);
+                assertNotSame(-1, inputPipe[0]);
+                assertNotSame(-1, inputPipe[1]);
+
+                List<SpawnFileAction> actions = Arrays.asList(dup(outputPipe[1], 1),
+                        open("/dev/null", 2, OpenFlags.O_WRONLY.intValue(), 0444),
+                        close(inputPipe[0]), close(inputPipe[1]));
+                pid = posix.posix_spawnp("cat", actions, Arrays.asList("cat", "/dev/fd/" + inputPipe[0]), emptyEnv);
+                assertTrue(pid != -1);
+                assertEquals(3, posix.libc().write(inputPipe[1], ByteBuffer.wrap("foo".getBytes(Charset.forName("US-ASCII"))), 3));
+                posix.libc().close(inputPipe[1]); // send EOF to process
+
+                // close the write side of the output pipe, so read() will return immediately once the process has exited
+                posix.libc().close(outputPipe[1]);
+
+                // Output from the process on stdout should be empty
+                ByteBuffer output = ByteBuffer.allocate(100);
+                long nbytes = posix.libc().read(outputPipe[0], output, output.remaining());
+                assertEquals(0L, nbytes);
+            } finally {
+                closePipe(inputPipe);
+                closePipe(outputPipe);
+                killChild(pid);
+            }
+        }
+    }
+}
diff --git a/src/test/java/jnr/posix/util/ConditionalTestRule.java b/src/test/java/jnr/posix/util/ConditionalTestRule.java
new file mode 100644
index 0000000..aa44a3f
--- /dev/null
+++ b/src/test/java/jnr/posix/util/ConditionalTestRule.java
@@ -0,0 +1,23 @@
+package jnr.posix.util;
+
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+public abstract class ConditionalTestRule implements TestRule {
+    public Statement apply(Statement base, Description description) {
+        return statement(base);
+    }
+
+    private Statement statement(final Statement base) {
+        return new Statement() {
+            @Override
+            public void evaluate() throws Throwable {
+                if (isSatisfied()) {
+                    base.evaluate();
+                }
+            }
+        };
+    }
+    public abstract  boolean isSatisfied();
+}
diff --git a/src/test/java/jnr/posix/util/DefaultPOSIXHandlerTest.java b/src/test/java/jnr/posix/util/DefaultPOSIXHandlerTest.java
new file mode 100644
index 0000000..f4ff76e
--- /dev/null
+++ b/src/test/java/jnr/posix/util/DefaultPOSIXHandlerTest.java
@@ -0,0 +1,25 @@
+package jnr.posix.util;
+
+import jnr.posix.POSIX;
+import jnr.posix.POSIXFactory;
+import org.junit.Test;
+
+import java.lang.management.ManagementFactory;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+public class DefaultPOSIXHandlerTest
+{
+    @Test
+    public void testGetPid() throws Exception
+    {
+        int pid_from_jmx = Integer.parseInt(ManagementFactory.getRuntimeMXBean().getName().split("@")[0]);
+
+        POSIX posix = POSIXFactory.getPOSIX(new DefaultPOSIXHandler(), true);
+        int pid = posix.getpid();
+        assertThat(pid, equalTo(pid_from_jmx));
+    }
+}
diff --git a/src/test/java/jnr/posix/util/PlatformTest.java b/src/test/java/jnr/posix/util/PlatformTest.java
new file mode 100644
index 0000000..7ae91ef
--- /dev/null
+++ b/src/test/java/jnr/posix/util/PlatformTest.java
@@ -0,0 +1,59 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+package jnr.posix.util;
+
+import jnr.posix.util.Platform;
+import junit.framework.TestCase;
+
+/*
+ * Admittedly, there is a lot of cyclomatic complexity and system-dependent
+ * testing going on here.  At least it's in one place.
+ */
+
+public class PlatformTest extends TestCase {
+
+    public void testBitLengths()  {
+        assertTrue("Not 32 or 64-bit platform?", Platform.IS_32_BIT ^ Platform.IS_64_BIT);
+    }
+
+    public void testEnvCommand()  {
+        String command =Platform.envCommand();
+        if (Platform.IS_WINDOWS_9X)  {
+            assertEquals("Fails on Windows 95/98", "command.com /c set", command);
+        }
+        if (Platform.IS_WINDOWS & !Platform.IS_WINDOWS_9X)  {
+            assertEquals("Fails on Windows other than 95/98", "cmd.exe /c set", command);
+        }
+        if (!Platform.IS_WINDOWS)  {
+            assertEquals("Fails on Non-Windows platform", "env", command);
+        }
+    }
+}
diff --git a/src/test/java/jnr/posix/windows/WindowsFileTest.java b/src/test/java/jnr/posix/windows/WindowsFileTest.java
new file mode 100644
index 0000000..1f540ef
--- /dev/null
+++ b/src/test/java/jnr/posix/windows/WindowsFileTest.java
@@ -0,0 +1,317 @@
+package jnr.posix.windows;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.nio.file.Files;
+import java.text.NumberFormat;
+import jnr.posix.DummyPOSIXHandler;
+import jnr.posix.FileStat;
+import jnr.posix.POSIX;
+import jnr.posix.POSIXFactory;
+import jnr.posix.WindowsPOSIX;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public class WindowsFileTest {
+    private static POSIX posix;
+
+    @BeforeClass
+    public static void setUpClass() throws Exception {
+        posix = POSIXFactory.getPOSIX(new DummyPOSIXHandler(), true);
+    }
+
+    private class Pair {
+        public File base;
+        public File leaf;
+        public Pair(File base, File leaf) {
+            this.base = base;
+            this.leaf = leaf;
+        }
+
+        public void cleanup() {
+            cleanup(base);
+        }
+
+        public void cleanup(File node) {
+            if (node.isDirectory()) {
+                File[] files = node.listFiles();
+                if (files != null) {
+                    for(File file: files) {
+                        cleanup(file);
+                    }
+                }
+            }
+            node.delete();
+        }
+    }
+    // FIXME: This is a broken method since it does not delete any of the generated dirs.
+    private static final String DIR_NAME = "0123456789";
+    private Pair makeLongPath() throws IOException {
+        File tmp = Files.createTempDirectory("temp" + Long.toHexString(System.nanoTime())).toFile();
+
+        StringBuilder buf = new StringBuilder(DIR_NAME);
+        for (int i = 0; i < 30; i++) {
+            buf.append(DIR_NAME).append('/');
+        }
+        File tmp2 = new File(tmp, buf.toString());
+        tmp2.mkdirs();
+
+        return new Pair(tmp, tmp2);
+    }
+
+    @Test
+    public void testLowercaseDriveLetter() throws Throwable {
+        // FIXME: Not all systems have a C drive but nearly all do
+        FileStat st = posix.stat("c:/");
+        assertTrue(st.dev() == 2);
+        assertTrue(st.rdev() == 2);
+    }
+
+    @Test
+    public void testFakeUIDGUID() throws Throwable {
+        File f = File.createTempFile("stat", null);
+
+        try {
+            FileStat st = posix.stat(f.getAbsolutePath());
+            assertTrue(st.uid() == 0);
+            assertTrue(st.gid() == 0);
+        } finally {
+            f.delete();
+        }
+    }
+
+    @Test
+    public void testExecutableSuffixesAreExecutable() throws Throwable {
+        File f = File.createTempFile("stat", ".exe");
+
+        try {
+            FileStat st = posix.stat(f.getAbsolutePath());
+            assertEquals("100755", Integer.toOctalString(st.mode()));
+            assertTrue(st.isExecutable());
+        } finally {
+            f.delete();
+        }
+
+        f = File.createTempFile("STAT", ".EXE");
+
+        try {
+            FileStat st = posix.stat(f.getAbsolutePath());
+            assertEquals("100755", Integer.toOctalString(st.mode()));
+            assertTrue(st.isExecutable());
+        } finally {
+            f.delete();
+        }
+
+    }
+
+    @Test
+    public void testBlocksAndBlockSizeReturn() throws Throwable {
+        File f = File.createTempFile("stat", null);
+
+        try {
+            FileStat st = posix.stat(f.getAbsolutePath());
+            assertTrue(st.blocks() == -1);
+            assertTrue(st.blockSize() == -1);
+        } finally {
+            f.delete();
+        }
+    }
+
+    @Test
+        public void testLongFileRegular() throws Throwable {
+        Pair pair = makeLongPath();
+        String path = pair.leaf.getAbsolutePath();
+        try {
+            FileStat st = posix.stat(path);
+            assertNotNull("posix.stat failed", st);
+
+            FileStat stat = posix.allocateStat();
+            int result = posix.stat(path, stat);
+            assertNotNull("posix.stat failed", stat);
+            assertEquals(0, result);
+        } finally {
+            pair.cleanup();
+        }
+    }
+
+    @Test
+    public void testLongFileUNC() throws Throwable {
+        Pair pair = makeLongPath();
+        String absolutePath = pair.leaf.getAbsolutePath();
+        char letter = absolutePath.charAt(0);
+        String path = absolutePath.replace(absolutePath.substring(0,2), "\\\\localhost\\" + letter + "$");
+        try {
+            FileStat st = posix.stat(path);
+            assertNotNull("posix.stat failed", st);
+
+            FileStat stat = posix.allocateStat();
+            int result = posix.stat(path, stat);
+            assertNotNull("posix.stat failed", stat);
+            assertEquals(0, result);
+        } finally {
+            pair.cleanup();
+        }
+    }
+
+    @Test
+    public void statUNCFile() throws Throwable {
+        File f = File.createTempFile("stat", null);
+        String absolutePath = f.getAbsolutePath();
+        char letter = absolutePath.charAt(0);
+        String path = absolutePath.replace(absolutePath.substring(0,2), "\\\\localhost\\" + letter + "$");
+        try {
+            FileStat st = posix.stat(path);
+            assertNotNull("posix.stat failed", st);
+
+            FileStat stat = posix.allocateStat();
+            int result = posix.stat(path, stat);
+            assertNotNull("posix.stat failed", stat);
+            assertEquals(0, result);
+        } finally {
+            f.delete();
+        }
+    }
+
+    @Test
+    public void unlinkTestWindows() throws Throwable {
+        File tmp = File.createTempFile("unlinkTest", "tmp");
+        RandomAccessFile raf = new RandomAccessFile(tmp, "rw");
+
+        raf.write("hello".getBytes());
+
+        // Windows won't allow you to delete open files, so we must
+        // close the handle before trying to delete it.  Unfortunately,
+        // this also means we're unable to write to the handle afterwards
+        // as we do with the non-Windows test.
+        raf.close();
+
+        int res = posix.unlink(tmp.getCanonicalPath());
+
+        assertEquals(0, res);
+        assertFalse(tmp.exists());
+    }
+
+    @Test
+    public void testFindFirstFile() throws Throwable {
+        File f = File.createTempFile("stat", null);
+        try {
+
+            POSIX posix = POSIXFactory.getNativePOSIX();
+            FileStat stat = posix.allocateStat();
+            int result = ((WindowsPOSIX) posix).findFirstFile(f.getAbsolutePath(), stat);
+
+            assertEquals(0, result);
+            assertTrue(stat.isFile());
+        } finally {
+            f.delete();
+        }
+    }
+
+    @Test
+    public void testFindFirstFileBogusFile() throws Throwable {
+        POSIX posix = POSIXFactory.getNativePOSIX();
+        FileStat stat = posix.allocateStat();
+        int result = ((WindowsPOSIX) posix).findFirstFile("sdjfhjfsdfhdsdfhsdj", stat);
+        assertTrue(result < 0);
+    }
+
+    @Test
+    public void utimensatWindows() throws Throwable {
+        File file = File.createTempFile("utimensat", null);
+        try {
+            FileStat fileStat = posix.stat(file.getPath());
+
+            long atimeSeconds = fileStat.atime() + 1;
+            long mtimeSeconds = fileStat.mtime() - 1;
+
+            // Windows precision is 100 ns
+            long atimeNanoSeconds = 123456700;
+            long mtimeNanoSeconds = 987654300;
+
+            // dirfd is ignored when passing an absolute path
+            // flag can be used to update symlinks
+            posix.utimensat(0,
+                    file.getAbsolutePath(),
+                    new long[]{atimeSeconds, atimeNanoSeconds},
+                    new long[]{mtimeSeconds, mtimeNanoSeconds},
+                    0);
+
+            fileStat = posix.stat(file.getPath());
+            assertEquals("access time should be updated", atimeSeconds, fileStat.atime());
+            assertEquals("modification time should be updated", mtimeSeconds, fileStat.mtime());
+        } finally {
+            file.delete();
+        }
+    }
+    
+    @Test
+    public void utimensatWindowsCurrentTime() throws Throwable {
+        File file = File.createTempFile("file", null);
+        try {
+            FileStat fileStat = posix.stat(file.getPath());
+            long atimeSeconds = fileStat.atime();
+            long mtimeSeconds = fileStat.mtime();
+            long atimeSecondsInPast = atimeSeconds - 1000;
+            long mtimeSecondsInPast = mtimeSeconds - 1000;
+
+            posix.utimensat(0,
+                    file.getAbsolutePath(),
+                    new long[]{atimeSecondsInPast, 0},
+                    new long[]{mtimeSecondsInPast, 0}, 0);
+            fileStat = posix.stat(file.getPath());
+            assertEquals("access time should be updated", fileStat.atime(), atimeSecondsInPast);
+            assertEquals("modification time should be updated", fileStat.mtime(), mtimeSecondsInPast);
+
+            posix.utimensat(0, file.getAbsolutePath(), null, null, 0);
+
+            fileStat = posix.stat(file.getPath());
+            assertTrue("access time should be updated to current time",
+                    timeWithinRange(fileStat.atime(), atimeSeconds, 10));
+            assertTrue("modification time should be updated to current time",
+                    timeWithinRange(fileStat.mtime(), mtimeSeconds, 10));
+        } finally {
+            file.delete();
+        }
+    }
+
+    @Test
+    public void utimenWindowsCurrentTime() throws Throwable {
+        File file = File.createTempFile("file", null);
+        try {
+            FileStat fileStat = posix.stat(file.getPath());
+            long atimeSeconds = fileStat.atime();
+            long mtimeSeconds = fileStat.mtime();
+            long atimeSecondsInPast = atimeSeconds - 1000;
+            long mtimeSecondsInPast = mtimeSeconds - 1000;
+
+            posix.utimes(file.getAbsolutePath(),
+                    new long[]{atimeSecondsInPast, 0},
+                    new long[]{mtimeSecondsInPast, 0});
+            fileStat = posix.stat(file.getPath());
+            assertEquals("access time should be updated",
+                    fileStat.atime(), atimeSecondsInPast);
+            assertEquals("modification time should be updated",
+                    fileStat.mtime(), mtimeSecondsInPast);
+
+            posix.utimes(file.getAbsolutePath(), null, null);
+
+            fileStat = posix.stat(file.getPath());
+            assertTrue("access time should be updated to current time",
+                    timeWithinRange(fileStat.atime(), atimeSeconds, 10));
+            assertTrue("modification time should be updated to current time",
+                    timeWithinRange(fileStat.mtime(), mtimeSeconds, 10));
+        } finally {
+            file.delete();
+        }
+    }
+
+    private boolean timeWithinRange(long actual, long expected, long precision) {
+        return actual > (expected - precision) && actual < (expected + precision);
+    }
+}
diff --git a/src/test/java/jnr/posix/windows/WindowsHelpersTest.java b/src/test/java/jnr/posix/windows/WindowsHelpersTest.java
new file mode 100644
index 0000000..09e6d69
--- /dev/null
+++ b/src/test/java/jnr/posix/windows/WindowsHelpersTest.java
@@ -0,0 +1,52 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ *
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+/**
+ * $Id: $
+ */
+package jnr.posix.windows;
+
+import jnr.posix.util.WindowsHelpers;
+import junit.framework.TestCase;
+
+public class WindowsHelpersTest extends TestCase {
+
+    public void testIsBatch() {
+        assertTrue(WindowsHelpers.isBatch("file.bat"));
+        assertTrue(WindowsHelpers.isBatch("FILE.BAT"));
+        assertTrue(WindowsHelpers.isBatch("file.cmd"));
+        assertTrue(WindowsHelpers.isBatch("FILE.CMD"));
+
+        assertFalse(WindowsHelpers.isBatch("file.exe"));
+        assertFalse(WindowsHelpers.isBatch("file.txt"));
+        assertFalse(WindowsHelpers.isBatch("file"));
+        assertFalse(WindowsHelpers.isBatch("filebat"));
+        assertFalse(WindowsHelpers.isBatch("filecmd"));
+        assertFalse(WindowsHelpers.isBatch(""));
+        assertFalse(WindowsHelpers.isBatch(null));
+    }
+}