From d1ca8f4f86e5551620aeddc5bcfaf8db6e8d5799 Mon Sep 17 00:00:00 2001 From: Arnout Engelen Date: Sat, 4 Jan 2014 19:04:28 +0100 Subject: [PATCH] Include notionflux in the main repo instead of its own submodule --- .gitmodules | 3 - mod_notionflux | 1 - mod_notionflux/LICENSE | 510 +++++++++++++++++++++++++++++++++ mod_notionflux/Makefile | 29 ++ mod_notionflux/README | 6 + mod_notionflux/mod_notionflux.c | 343 ++++++++++++++++++++++ mod_notionflux/notionflux.h | 21 ++ mod_notionflux/notionflux/Makefile | 32 +++ mod_notionflux/notionflux/notionflux | Bin 0 -> 24065 bytes mod_notionflux/notionflux/notionflux.c | 248 ++++++++++++++++ 10 files changed, 1189 insertions(+), 4 deletions(-) delete mode 160000 mod_notionflux create mode 100644 mod_notionflux/LICENSE create mode 100644 mod_notionflux/Makefile create mode 100644 mod_notionflux/README create mode 100644 mod_notionflux/mod_notionflux.c create mode 100644 mod_notionflux/notionflux.h create mode 100644 mod_notionflux/notionflux/Makefile create mode 100755 mod_notionflux/notionflux/notionflux create mode 100644 mod_notionflux/notionflux/notionflux.c diff --git a/.gitmodules b/.gitmodules index 07c952db..a0ecf668 100644 --- a/.gitmodules +++ b/.gitmodules @@ -13,6 +13,3 @@ [submodule "libtu"] path = libtu url = ../libtu -[submodule "mod_notionflux"] - path = mod_notionflux - url = ../mod_notionflux diff --git a/mod_notionflux b/mod_notionflux deleted file mode 160000 index 529a273b..00000000 --- a/mod_notionflux +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 529a273bee9dc05a6353d56860a3d4bdc9dd833e diff --git a/mod_notionflux/LICENSE b/mod_notionflux/LICENSE new file mode 100644 index 00000000..cf9b6b99 --- /dev/null +++ b/mod_notionflux/LICENSE @@ -0,0 +1,510 @@ + + 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. +^L + 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. +^L + 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. +^L + 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. +^L + 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. +^L + 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. +^L + 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. +^L + 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 +^L + 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. + + + + Copyright (C) + + 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. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + + diff --git a/mod_notionflux/Makefile b/mod_notionflux/Makefile new file mode 100644 index 00000000..dee2f8c0 --- /dev/null +++ b/mod_notionflux/Makefile @@ -0,0 +1,29 @@ +## +## mod_notionflux Makefile +## + +# System-specific configuration is in system.mk +TOPDIR=.. +include $(TOPDIR)/build/system-inc.mk + +###################################### + +INSTALL_SUBDIRS = notionflux +SUBDIRS = $(INSTALL_SUBDIRS) + +###################################### + +INCLUDES += $(X11_INCLUDES) -I$(TOPDIR) +CFLAGS += $(XOPEN_SOURCE) $(C99_SOURCE) + +SOURCES=mod_notionflux.c + +MODULE=mod_notionflux + +###################################### + +include $(TOPDIR)/build/rules.mk + +###################################### + +_install: module_install diff --git a/mod_notionflux/README b/mod_notionflux/README new file mode 100644 index 00000000..114a0efd --- /dev/null +++ b/mod_notionflux/README @@ -0,0 +1,6 @@ +This is a simple "remote control" module for Notion. + +*** +*** THIS MODULE IS PROBABLY A GAPING SECURITY HOLE! +*** USE WITH CAUTION! +*** diff --git a/mod_notionflux/mod_notionflux.c b/mod_notionflux/mod_notionflux.c new file mode 100644 index 00000000..c55369c2 --- /dev/null +++ b/mod_notionflux/mod_notionflux.c @@ -0,0 +1,343 @@ +/* + * mod_notionflux/mod_notionflux/mod_notionflux.c + * + * Copyright (c) Tuomo Valkonen 2004-2005. + * + * This 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "notionflux.h" + +typedef struct{ + int fd; + int ndata; + char *data; +} Buf; + +Buf bufs[MAX_SERVED]; + +static int listenfd=-1; +static char *listenfile=NULL; +static ExtlFn tostringfn; +static int tmp[CHUNK]; + + +/* Without the 'or nil' kludge tostring may have no parameters. */ +static const char tostringstr[]= + "local arg={...}\n" + "local callable=arg[1]\n" + "local result=callable()\n" + "if type(result)=='string' then\n" + " return string.format('%q', result)\n" + "else\n" + " return tostring(result)\n" + "end\n"; + +static void writes(int fd, const char *s) +{ + if(s!=NULL) + write(fd, s, strlen(s)); +} + + +static void close_conn(Buf *buf) +{ + if(buf->fd<0) + return; + + mainloop_unregister_input_fd(buf->fd); + + close(buf->fd); + buf->fd=-1; + buf->ndata=0; + if(buf->data!=NULL){ + free(buf->data); + buf->data=NULL; + } +} + + +static void receive_data(int fd, void *buf_) +{ + Buf *buf=(Buf*)buf_; + bool end=FALSE; + ErrorLog el; + ExtlFn fn; + int i, n; + bool success=FALSE; + + n=read(fd, buf->data+buf->ndata, MAX_DATA-buf->ndata); + + if(n==0){ + warn("Connection closed prematurely."); + close_conn(buf); + return; + } + + if(n<0){ + if(errno!=EAGAIN && errno!=EINTR){ + writes(fd, "Error: I/O"); + close_conn(buf); + } + return; + } + + for(i=0; idata[buf->ndata+i]=='\0') + end=TRUE; + } + + buf->ndata+=n; + + if(!end && buf->ndata+n==MAX_DATA){ + writes(fd, "Error: too much data\n"); + close_conn(buf); + return; + } + + if(!end) + return; + + errorlog_begin(&el); + if(extl_loadstring(buf->data, &fn)){ + char *retstr=NULL; + if(extl_call(tostringfn, "f", "s", fn, &retstr)){ + success=TRUE; + writes(fd, "S"); + writes(fd, retstr); + writes(fd, "\n"); + free(retstr); + } + extl_unref_fn(fn); + } + errorlog_end(&el); + if(el.msgs!=NULL && !success){ + writes(fd, "E"); + writes(fd, el.msgs); + } + errorlog_deinit(&el); + + close_conn(buf); +} + + +static void connection_attempt(int lfd, void *data) +{ + int i, fd; + Buf *buf=NULL; + struct sockaddr_un from; + socklen_t fromlen=sizeof(from); + + fd=accept(lfd, (struct sockaddr*)&from, &fromlen); + + if(fd<0){ + warn_err(); + return; + } + + /* unblock */ { + int fl=fcntl(fd, F_GETFL); + if(fl!=-1) + fl=fcntl(fd, F_SETFL, fl|O_NONBLOCK); + if(fl==-1){ + warn_err(); + close(fd); + return; + } + } + + /* close socket on exec */ { + int fl=fcntl(fd, F_GETFD); + if(fl!=-1) + fl=fcntl(fd, F_SETFD, fl|FD_CLOEXEC); + if(fl==-1){ + warn_err(); + close(fd); + return; + } + + } + + for(i=0; iSOCK_MAX){ + warn("Too long socket path"); + goto err; + } + + listenfd=socket(AF_UNIX, SOCK_STREAM, 0); + if(listenfd<0) + goto errwarn; + + if(fchmod(listenfd, S_IRUSR|S_IWUSR)<0) + goto errwarn; + + addr.sun_family=AF_UNIX; + strcpy(addr.sun_path, listenfile); + + { + int fl=fcntl(listenfd, F_GETFD); + if(fl!=-1) + fl=fcntl(listenfd, F_SETFD, fl|FD_CLOEXEC); + if(fl==-1) + goto errwarn; + } + + if(bind(listenfd, (struct sockaddr*) &addr, + strlen(addr.sun_path)+sizeof(addr.sun_family))<0){ + goto errwarn; + } + + if(listen(listenfd, MAX_SERVED)<0) + goto errwarn; + + if(!mainloop_register_input_fd(listenfd, NULL, connection_attempt)) + goto err; + + return TRUE; + +errwarn: + warn_err_obj("mod_notionflux listening socket"); +err: + if(listenfd>=0){ + close(listenfd); + listenfd=-1; + } + + /*if(listenfile!=NULL){ + free(listenfile); + listenfile=NULL; + }*/ + + return FALSE; +} + + +void close_connections() +{ + int i; + + if(listenfd>=0){ + mainloop_unregister_input_fd(listenfd); + close(listenfd); + listenfd=-1; + } + + if(listenfile!=NULL){ + unlink(listenfile); + /*free(listenfile); + listenfile=NULL;*/ + } + + for(i=0; i=0) + close_conn(&(bufs[i])); + } + + extl_unref_fn(tostringfn); +} + +char mod_notionflux_ion_api_version[]=ION_API_VERSION; + +static Atom flux_socket=None; + +bool mod_notionflux_init() +{ + int i; + WRootWin *rw; + + for(i=0; i%U~MeP+7RPfsSE7l6Nx8+*xpNPFupGYhD*V>OWXHI6k z{@-`M|K!W;wbov1?X}ll`*qGfXJ38eT3M2axMZ@5AXb`PP4Q|@-?>g>0a_KY!S4;E zh*$x)==iEhby9kYs}`w^^O@k^jDXAua&=NVm6Js(=~4^PU)4$JBl#pLCB#X8Q4VcA z&gsYVcP6E0g&ldxax#}Y%jM1rex6?9hFvn$&&>a)a=laK>ZG)e^NG~V)26qhUW5zA zGrVAYby6DOd?FQcn?TM=zWC+fX<5MEzGP8Zz*`dV2V(;z164~(mMkibgi0%^ZsfzN zt=rH_`Gr56gq4kMG4cG`=Qh1~qPucw_=l$!&UIawdHA(GMVMDW68_)+j8hskS7#!v z5dNpb|C;*O-hJv1-`dmJ>Tz87a@*7s2mh=rd;h@H%dfttkTlmgP&hsXJ)4M@OTPX< zQuDjh=-ES3(*tSfQ_|>Jl7?p4kM^Z#=i`ftd z)YD0@+)OfPuTG*nC8lS;LC>9(Um>pCWPSquu&ts3JKhqaHngl)y}q!o%O8pQ!Y%7- z1EHX=#nT?}5moK#2?fP@xW1ok*x-moG{p(QrraZsHpN6M!Wg3X_gdFzD;REU!OEI=g&PuwI3{U`P#w zIy_N-C`iISj~6+BOgekR{$R9|>gwqQUMz(>qsId}`osPx)WzrZL_Lt*9*MAAAO*c- zU1P(VTD7vYvUD+FW0}k+AesN^CL~=hLK6JxeNoqQg6c;Zf);+U6B z5|@Z8oWlxr^!+;eG#&jc*ONgKb0A(X>*yvO{eq4z<_5ej>FE0Tb67{$&mUKG^b8&S zs*WyVnqHFF5)6^qo5TBpuy7^sdc)z%nh{N!)jxidu&MjS|n;PP6>c z#p5As^oD%+&6!aR5aQjKHF9Ybt{cW7j-fH~GR0-YF>FUpQT$pK;20t!$0`0k;usnu zM=Aae;usPmhbaCg;us1egB1S_;%N3rFU8Lzj!i$Zlj1KTj!iz&MDb@4$EF^srudVH zV-t^*Q~XiHv1vz~6#psW*rX#4ihmz*Y|0Tr@%s_SCLFnP9r14=?x6Lj_&tc{()v^U zPQ=I4`cwRN#PewV0k7Fob4yKYO-n=k!`5bS{=m?vw0GUms3|tyePFNc>1r64hbMs? zG)BhBTEH&58V>AnIVw)Mht7@GSA6{bG5060xJS>q@Az~S%<6NT+>SDrz~wbhV>?ug z4*wBKg64F`Ei0h(le>T+=WDNF%f?@L5_z5;LYem%+sW_I{Kqi=K=wG0aL1o_cO1Ti zglFE&aGMSf)4baq73YUnn-N_3hfF7Fh(9-+3AV1k>rW?7QynqD+(W+vJ4YMi@44e6 zb^EWrf9&MHLnc}+jkt$C-Ieq84Zv1${v@>oe}-SXjx~;-KKT}K4wSkN?s1tL)Zg`SY+}QKsLR1hb;mz>|5*IR zPtISy`T07R1SU^#fXPo|uRD1hdc*MdKBKjd&ZH>#H$L+Iv8NG^{~nD!xM_4a6TEu) z3>Ga>zd_MgAx$ED9n#UWv8;Qbm=(>@g)8c#WhX7LULNTJD+l+uq~`duR4=V?)N&Gg z$MA7L?)VIwaPOoi(JEf_@KVSCUpyB(1O0HI;?%7>YPQ$xsJX31JzepqhWIPDx#MrT zhu*r<)Y9<6DJOdNg=Y>qFnQt1IPk_3e;pnDFlWZs2wo@lfznoY39cL5Lsu1d{Ox{u z$LSN8hn4?u$4Sf@y_7R!kn#`c_@B9I0)BV=S@$#VtaeK;yI;8)1K}r`@Oco1Kw9p$!ymegq`xgVQ*ExQAArwE{zQx@JOt>&a8Fn*sjOmv@YO z1w?XYkdX+aO~XA<7wWa)2tb?N@oNxzO`z`SMNsjIQ^Q#r!)Ab>XT?9OX{m|-3X1=z zIsR%*(_L@uUE%I{)gAw@y7+s;2meCjX3Fp)01l9$tLEtMhOTBtFP^NzKso@0Mzila zwfEfI)9(A+(sP$jZLN!6ntOq@!D&?eSFRcqR|&=cXV@$hzi};<;!0HfOQG}(sykh? zr9S>F8x26^FPj_V|AqrX<3X>hyYXPawX+eTtfdjULYq6j$5rl*M_pC!c#EqVdPNKM z9sqO@M1YRT?gMqMYWIN_S5+0(ZX8}f>k+%jePFr!uF>ck_s|~D9Cg)!&c=FZ^TOe|P(v)IyT0PQd+3ze z{mih8wHiX=PH54XW7vW`FVKa7d+6*a2C^=Un`=&Bley!sK2Z(nlQSsWyNoR zP@bzffwKe*mj_lZ$-pr!--SY-ywVu|HH@EeDC-FTU0pIk-z{}e66 zcyElq(-{A_E~icK_kr!;^aBBK{{b&F1VGM4XszPL1K7|*XR1!~ z{`A3VK1cH@8CQQdM8=UVu+H=cyGV(Tv_?E#z8jseRP7AJ2AsE+_?#UfuWtuw35A?J zv5syhE=Eg9YY^Aq&S=O9E99Wl%a+ciMBT8lrD5X+b^XRV4z6u%ZBv^!*4|v-Le~2u z5h%#%ffaeFb3+K1#Li$S>I}z%LC9E5HiVpPg;c~Gwh4>hJq0v)^mz!Iqr3FqTc_>=qQdB7r?Q&Af5;@iu*_l^!Q7V zPJr|(q)Q-mKwuq#6!+DCfOG)T|A2x1EToemu!bQWfV2tp*r4YO@C9~0ONey)W+DwZ zq$yb$wnI{e1L=4V=xzw;c_eYA<|o9(`Okg~Wnhpijy+XlOPx|K z*C@qn6=#i701Rss+X7&H1pe28+rHM`oL>bx+TjKI%izaVvan-KvK@73M-AFh2X>g8vQkx> z#t>|me*t|?C?}4Do9?!L!_ui#4`m!Qf75iYEVofswCA_Lw;%Y#-b;U7;rAt9=Bc=( zH0gPsioJx`r;9y=*oRN%xVRrUh2z4HVy||B=ZpK2BLAc7qajRp%GDGXd#wEyhKs$` zQJydMLSb&G*aH>tRKKUdOYHHE^Zl3bjkxb9`h(c3i9N>AjOrwM8^?v+Zk~!gnsLD3rKR1vH>mMfs{qVsYp5fZH3*uwLaCOU zDA*5yZE2)nHWsk+2?TLAvUF4MDD*_@_5)bqr-0XKJz51i?OjkQ>-U~XyUi+Kr@daI7uzLp zvGpqQm)nnlE3BU)ya>u{Msse*s$GlVpzpAbP6GyIjTuKEiB?w$qAH0ZW+jA(EFqT- z6ub#iIZIKeN%|8yVbGc_tptS%HC~aZ^~!C?kt3~v44X0m&2dP-LHiYqJ8LdgUZ5Pw z(2%LhO3WEg5vTH<3=MH9xRJBwQKVRT3Xy!t4XVqPm1y?_np34zp*tp0Q>&HRk!_N6 z8zgS!BIXoGZv$JCB4hO@OX#XLC5T8NMRqDrV-==QZQXQM=SV=w$8x4pq*s}bhEAhM zRCxiB=@Q240LeN|TNeFcwatQ@9GtVPGo&(r9R*gGbf4y`8@Q{e>t|DKHbp_nITXoK zJjhl|5eLaRjdhqSZKJw3z;Di@Sl9>D`?mZ=$(&d5RUA;WIQXi{>;b|BgA?6lqaDK`$y4X;W^e!9$VlN*-F^pvX?;9NLyE z&$MC#1!;)LtWDO_5RqA%3}Q~cjI|z60%i>vRGiqT6DZq$#wkIJUY zHGsUVd*_ygILibYRx6(0rbZ#ioB)#Jt8jo2apUacOY^DHSLOmH-W6PDRMRM zC+N^QRE9`-IG|XIDQ1@P@BxW+E;Y_3U4X<*ShLPsnKkz(a{$RtsuT=@{WWQtTN|A|GIC{nF#MZFe^xRu+G%}S9bC4vev zDAJ~sTF?k-nGItS7lyV>X|)Yw@5y4rMASa$LC?k%iJRg3|AIUnesa@LTbT2DLo0~sr~*S;5gw;+it}}1=$*1i2JD0*p za^8!%MPdmk9%o1o%!1v;%m`%N$`*;FXcp&*jEBa7+*wkq=>w^ixJr1&UE?WHs({s? z*YAVck-JkX zrx`XwGhsGk`FEiW?XgZkv3tIPXprY+fCJ`SL{-ZW#pO@2kLz2(_08Qyq!pMOhuoqF z&wT=HnVU)Nk-v&|%YA6DEkbNgm(4kw%-h2`F9N6QTO4`GPDSjdDqcy#A74ww$2iM+ zPL>|X%Hs7X#^UiVDXT{@`Va4HV?AhI4Isr&a|Kmg0UACZbNeB;=p~-}7MSxUH+)Y@ z!(Y=Ie))3@pFfBjfIbYgzi_r|JWG1u9@rtzq=DXtf&Ncm!vY%YeHg57BT56FqBv+Q zph4e{+FB8%f!~kze-qG|5d8fZ{CHEcgm!@4m}fftgMFpg*T&~)b`k0JvabOt56mn3 z3IL4=^a5}n0zLq;KzZ3V0Px9G*+u|xonKZ5zy%B6%v9WKNBs})tGJ&6$M;n{M1d3g zDvtr+fG%J3ZCcm~NKJXGv|;%Uc1I`-%DRA;^&XZSp<> zi9_CtNdd-@-0#Fzk^76~2qE)+&b99V?epHyA#lx~1)h-hVN8F-b418W4-_fF`}@%Q zYr)i+9zf99`v6%mMMhy9LQVj>5WIT_YLX9k&jq17=^_Ez!!^mlRAVgiP7hUtqy=gy zZG`H{wrZ%KQ~}ikX&CtM_LFq5f(vffY=^)y4V+OP7AlmdSAPb^s(?JaGo8W)( zMy_EQ*Kii(muxoSFpNR+Z9p^W0Oi`xIU{+r0hp1Sn30>&$Tq1;^FEL_5wi4VF7xv- zGSGv%(BS*fA(AZzhE_21emcg&==FCE(c{E3OXUV;kh*rOZLu2KEP^Ru*-nD&sPcVazfrF= z!y!bACUeo(!F{tGeB`bcW5c}lJR4^cvK(8!nNz~NEa|ydL9EzFuKWmidqAr4Isk_N zDB8wZ{tQLM9c&6HCq;K~az;LkF2aJL#M}YXMA74%2M41w4n{5~^Pc16IrOgAVs92h zH**_WbHU9WM7k)PT(pmKtOS86xqKu%&L7ER^o)bqv*;nth4W7}dyr8jj-5>K`E<`LzcZ;!d=}(A(x3u-%MQclIl8O%B{o^ zaW!^idyul?xXxI^Ho>|Y&%0U&>BeRg=3^}~aZJm^K_YXT_S3A$4La5@9) z&d^`%U#pkm%Jq^R#c(X6=8@HJ<2KGomu!!uDDI3_68(8ZSPV)Z1$fe2)Zs?W=cta? z$Lb(Ub`sI+v71rPF<-BK3^!-5TTlSI8mDf?y=j&eg|QbgeN>9IMnHnUu^-L?uA&*_vP#$c&pH&6(VghdG%Rg8W%|z_0=~hS_;iLQLUe7ABT6 zQA1&=!5J;cmpqO1Bei_S^Y7wM20i*#(xgqmDwd`5M_ch^itT{9E9WN3(@ z_?;58PX#r3);)JhL@qeIrT_*Xkpa64P-RP@YPR0eq?|bkv#^ljObN4LeY_~C@Oe-M zVP(uOl~zwqqiumDNn43dIT%_x4HRsaS|_z-ZUq;YSx5zCE6)TPEGZWu4t$l1c*a7V z5kOz0FFC2)#msC3mn56Fg61z}F8a=z$ykFb;SJGh%Mvm|;zoQ{vm6aZ#b_{6SI|g- z*jbsV+3Lv{t*bN@mN}D|iq(3O&|6(flFfr+z9Qqsm@ayxzd)o*5`AX?@v>MXT;>mU z1Y%xa*+A72b;%-rmb@z%D{J>hBjod0BD*<9z~5fh)zLAQV^L|95Kq?CR#A~efW19^ zK#mXMOFMAPiSF+8MM}HTQUO9$B2ll`*9kBTNNte7;MxYIGYAi(h5)qCL%9Ns1^tl0 zV0>)u@p{8dFMs$>;aHFru%bQY4@67+L7Wy)BhzltamxZ$(J&@XPrfn`#vxhk>`g_| z%&n&We{im}m6;0v;q4M4o281z*DKXXPZUW{>2u1;`b}p@o5^SE zG)=Lsc-yq|PMb@vpZKq~SzEU*f9b)krfAeuc+;?}z54zQN4J(UNz`MqmVGI2`N}fe z^o{o(E_r?V%HmM{?{^F9vEus?CiU-e~aH%v~r7I zo|7M5Wt!Fopl#-sk8F7*{1&P*|VFU>s3RYoobZy_=9SXr#C{>j&3~l`{jTyNXoiHJ-#vzcrX_A1!NQ|qf3QpK6=$exLxE5j zDw^tiH9tS1Qj2;#16tt`|Ls1gktZ69K*^zKNCkI=!fKx{9AW3F13pj0C-OXB(&b?l zsj^+Z-FS$FKsWKk0#UWA1J7XxXsklfJ{20Ht%=nOkB&nFga{rtapJQ;wM`rh4|;vQ z(Qas{&VZ*2?C}pkb<|F*6|kuhG!`0EZP=)Si|HY4wIdc*J3@h2PmuYmxn*;G&3Z!H zfvFD#ych}KG7=2q(ehYO?ez5c1G`DY)8|uTP;59t>ac9m)9?2}qN=?f?;@5gPCDoA zO?jlf&l8CG2#jB7FeGXy3`(h`J)ZC`0I6}C>(*;digbj15Qr$?3qn)EPA_RZ3Wq{b z)gSDQ;bHa2F6OUTFyikD`n;@Wpq+-g+8Ygv!ogtD-%W}B0bc;g5fy@fqiO_$Q-o1h ziZEiHODYIhu+Lz5)MM=!5y4nbJJhQ^;OW@KmEYoz#5@7gL#u&J)CmmyBtIU}-$jC~ z*3iT~7%&6e8Ik1I1;mgEO(Uum!*>xP9+e)|hh1?f7Vhw=o&ad2c3~%?0m0r2z(}Fd z$NB+j2P3hTk!UFFBRu#Mg6Kc?VgvO$4Z|^SJ|H(%f=A%mhQ@lWvzBX6MUrzhuc~e9 zYBiq4EE?)+Yn#No3L>jYgO+KK0JITgA-+N7tYs$voFzTcSkSk!%NO*8{T+aM!X4c! z*}GZJk}hY-MsRm;D1z?eao>S2e?U8dFL-?7s}#B!2AVbIV{z9BZc%x`1P_*xNQWl~ z^R17@TCk5cdW84}qO5gT@2vzcdzl8cFN%lRL?>)(3i+`=(ScbE9ZZYgOUDyBT2mJ_ z)zEWo;?<8>#HX^?Ka8)Nh<82OcSGc}&ew&J#w-Z3F+@}nf*Bf7L>cLWxCw<>(=$89 zzE`3Kp?+*iS+Ypgg%0ftTF;t;jJ-g|Y;t6;4F)!9OZme&suVru3 z1Q%BN271ApK5f=v?Z#qq-DVg)Ien1;77Jhr8+@TR#d=xQc}5lQ{0()2vP`_U19o(f zo^GGNt2>HO66Qs1uGzwe?D|c-oz=GbfoL5XL*LIy)Rh($@O4I0_AXVM5-6WG^(1r&@Sil&4gntf zf7I0?z@KQOTmE~gO#=K!jkH~WdJ8sv0Sh!;4{M}mqm+2C@)eDxNjx<9UV>zl5|%uf z@SFgzCF~ZUcuJAlb7OV22=Hop&yAJZB*0J7*H%1@`BkE7;z`TL>1!+O-34T$tWdsu1(Zg zfHx&-BS7)Ejk!T!n-j7E{JKWkCcuNA>q242>O`ReOxUq0l^rdb9sLPe0VeF&l**2= zEh6k#kq{K1zR*otp&bcEVz|Wpk(^Ay(kejlWQ{pPV9g0e0g5khr1qL9Azu@0$v2b$ z6X#gHY2QggYJj86CiUIMDJT+coAuNJicv&>+n5#6hy9YLLkVeBS?G_N-%k`4d zU?}PMtGJ8zmJZYt>!74pKqfCm{l z)EkImk+6>`jpB~1lzxbyG#sK^m{MQ2+8Orr_|$IL*J&7&P(9%=Y{;mDfWOocre?q% zssoCKJp%r)Qkcee*eI8FgnD{>L8STGV_hJOd(VhK{jj~%vfA6jzCMBBE?K~|rkot= z5Fpp|KXc)GD0nwm76iGPrz{cgp@>T|;IjyO_e01hzC*)sr-9#Wz$-|y{0h06rwn%) z_>J;)@c;4XXh_KKl&g8l@M=!C@YF_^&|7hSh%0En!GD(&f@82Eg@+V00Wt9JrB+Ga6qcYw61wCWD8tu8pX+mCnKW2c-mm3rq z^^Fo%ez}1zAUNjhVmF$p7;Kmi7t9 z@XN?skw$(FcgQ|N|1t8elv4ZeN0lrsG&Gpef9^EppSqEy7xf>-A!B)))5!mAJxg~Q z=tf=~rVK8k*QZ?GV-PUPBW`dJy^ivg?@m5|;yM7UWSl=RJ5~8)8%rd^fS0PS=`Is; z%hf69vbN4irkk|&OETT8txJ;W7Hz$eOt)(5h-7+3%J*SS;1x0NC)4fPe4b1nr_IyJ z^s(O=WArR-UQMQFYx89?J;nFOC_P7;-;(JLZQe?z=W6p&GJU)@&m`0HwD}{Mp0CXd z$@B>+-}g0_2Am=TRda*8noagYjjNd`>sM?NPw##(yVJ0p-OlNU4D=AE8^0597h(1s;`WH~hOINl#^+On z>A7Oi^8)1`8|Ufj#nvIYleodYHlE$Jm)m=ZUfXrI7O*?JS}EWBW_3 zgxuN0$;SaP_BTtZzpwaZpgU904^sNres^CQJ&#DKzq@!c4gYy5^>-aFN~yoE_Sgp>e;WP+Y3TQ*q2qfz&J^@t06kYO zAiaii&mmnmFNo>-g3SDOi2F0n>BDKt{V)yPY)btdPP>WeH{QN-m{Na-b1LUIzRWSx zl)Bu-rqq6DNW*_?8hWpZ`ORq09&V5E)t>v(l>2BJ{m-SLze?$2*8>+#slPk=r!;z! z4=AyNUHJYVKX4!p-r;F~JZ01ojz*%f&dyRi<#1E&X0@@QxkXh;;$x+1v`6j0FOEh? z3X-aNLuywb)b0tW-e@QsQ9ZE%(h=(E#dA5{(j^O*RiPh^}kgxTdC2-MDsb zbA5~2QnRM9UKJl9?TEzKCsd6GO{%N)pB??YZ@c2{NnR8?VwEgPkI5vHXzLgX;NL!_ zwtU{ebAv8k((bHhbwEqiaPjveL literal 0 HcwPel00001 diff --git a/mod_notionflux/notionflux/notionflux.c b/mod_notionflux/notionflux/notionflux.c new file mode 100644 index 00000000..88d0c167 --- /dev/null +++ b/mod_notionflux/notionflux/notionflux.c @@ -0,0 +1,248 @@ +/* + * mod_notionflux/notionflux/notionflux.c + * + * Copyright (c) Tuomo Valkonen 2004-2005. + * + * This 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. + */ + +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "../notionflux.h" + +static void die(const char *s) +{ + fprintf(stderr, "%s\n", s); + exit(1); +} + + +static void die_e(const char *s) +{ + perror(s); + exit(1); +} + +static void mywrite(int fd, const char *buf, int n) +{ + while(n>0){ + int k; + k=write(fd, buf, n); + if(k<0 && (errno!=EAGAIN && errno!=EINTR)) + die_e("Writing"); + if(k>0){ + n-=k; + buf+=k; + } + } +} + + +static int myread(int fd, char *buf, int n) +{ + int left=n; + + while(left>0){ + int k; + k=read(fd, buf, left); + if(k<0 && (errno!=EAGAIN && errno!=EINTR)) + die_e("Writing"); + if(k==0) + break; + if(k>0){ + left-=k; + buf+=k; + } + } + return n-left; +} + + +static char buf[MAX_DATA]; + + +/*{{{ X */ + + +static Display *dpy=NULL; + + +static ulong xwindow_get_property_(Window win, Atom atom, Atom type, + ulong n32expected, bool more, uchar **p, + int *format) +{ + Atom real_type; + ulong n=-1, extra=0; + int status; + + do{ + status=XGetWindowProperty(dpy, win, atom, 0L, n32expected, + False, type, &real_type, format, &n, + &extra, p); + + if(status!=Success || *p==NULL) + return -1; + + if(extra==0 || !more) + break; + + XFree((void*)*p); + n32expected+=(extra+4)/4; + more=FALSE; + }while(1); + + if(n==0){ + XFree((void*)*p); + *p=NULL; + return -1; + } + + return n; +} + + +ulong xwindow_get_property(Window win, Atom atom, Atom type, + ulong n32expected, bool more, uchar **p) +{ + int format=0; + return xwindow_get_property_(win, atom, type, n32expected, more, p, + &format); +} + + +char *xwindow_get_string_property(Window win, Atom a, int *nret) +{ + char *p; + int n; + + n=xwindow_get_property(win, a, XA_STRING, 64L, TRUE, (uchar**)&p); + + if(nret!=NULL) + *nret=n; + + return (n<=0 ? NULL : p); +} + + +void xwindow_set_string_property(Window win, Atom a, const char *value) +{ + if(value==NULL){ + XDeleteProperty(dpy, win, a); + }else{ + XChangeProperty(dpy, win, a, XA_STRING, + 8, PropModeReplace, (uchar*)value, strlen(value)); + } +} + + +static char *get_socket() +{ + Atom a; + char *s; + + dpy=XOpenDisplay(NULL); + + if(dpy==NULL) + die_e("Unable to open display."); + + a=XInternAtom(dpy, "_NOTION_MOD_NOTIONFLUX_SOCKET", True); + + if(a==None) + die_e("Missing atom. Notion not running?"); + + s=xwindow_get_string_property(DefaultRootWindow(dpy), a, NULL); + + XCloseDisplay(dpy); + + return s; +} + + +/*}}}*/ + + +int main(int argc, char *argv[]) +{ + int sock; + struct sockaddr_un serv; + const char *sockname; + int use_stdin=1; + char res; + int n; + + if(argc>1){ + if(argc!=3 || strcmp(argv[1], "-e")!=0) + die("Usage: ionflux [-e code]"); + + if(strlen(argv[2])>=MAX_DATA) + die("Too much data."); + + use_stdin=0; + } + + sockname=get_socket(); + if(sockname==NULL) + die("No socket."); + + if(strlen(sockname)>SOCK_MAX) + die("Socket name too long."); + + sock=socket(AF_UNIX, SOCK_STREAM, 0); + if(sock<0) + die_e("Opening socket"); + + serv.sun_family=AF_UNIX; + strcpy(serv.sun_path, sockname); + + if(connect(sock, (struct sockaddr*)&serv, sizeof(struct sockaddr_un))<0) + die_e("Connecting socket"); + + if(!use_stdin){ + mywrite(sock, argv[2], strlen(argv[2])+1); + }else{ + char c='\0'; + while(1){ + if(fgets(buf, MAX_DATA, stdin)==NULL) + break; + mywrite(sock, buf, strlen(buf)); + } + mywrite(sock, &c, 1); + } + + n=myread(sock, &res, 1); + + if(n!=1 || (res!='E' && res!='S')) + die("Invalid response"); + + while(1){ + n=myread(sock, buf, MAX_DATA); + + if(n==0) + break; + + if(res=='S') + mywrite(1, buf, n); + else /* res=='E' */ + mywrite(2, buf, n); + + if(n