├── COPYING ├── INSTALL ├── Makefile ├── README ├── cssl.c ├── cssl.h ├── libcssl.spec ├── libcssl.spec.in └── test.c /COPYING: -------------------------------------------------------------------------------- 1 | GNU LIBRARY GENERAL PUBLIC LICENSE 2 | Version 2, June 1991 3 | 4 | Copyright (C) 1991 Free Software Foundation, Inc. 5 | 675 Mass Ave, Cambridge, MA 02139, USA 6 | Everyone is permitted to copy and distribute verbatim copies 7 | of this license document, but changing it is not allowed. 8 | 9 | [This is the first released version of the library GPL. It is 10 | numbered 2 because it goes with version 2 of the ordinary GPL.] 11 | 12 | Preamble 13 | 14 | The licenses for most software are designed to take away your 15 | freedom to share and change it. By contrast, the GNU General Public 16 | Licenses are intended to guarantee your freedom to share and change 17 | free software--to make sure the software is free for all its users. 18 | 19 | This license, the Library General Public License, applies to some 20 | specially designated Free Software Foundation software, and to any 21 | other libraries whose authors decide to use it. You can use it for 22 | your libraries, too. 23 | 24 | When we speak of free software, we are referring to freedom, not 25 | price. Our General Public Licenses are designed to make sure that you 26 | have the freedom to distribute copies of free software (and charge for 27 | this service if you wish), that you receive source code or can get it 28 | if you want it, that you can change the software or use pieces of it 29 | in new free programs; and that you know you can do these things. 30 | 31 | To protect your rights, we need to make restrictions that forbid 32 | anyone to deny you these rights or to ask you to surrender the rights. 33 | These restrictions translate to certain responsibilities for you if 34 | you distribute copies of the library, or if you modify it. 35 | 36 | For example, if you distribute copies of the library, whether gratis 37 | or for a fee, you must give the recipients all the rights that we gave 38 | you. You must make sure that they, too, receive or can get the source 39 | code. If you link a program with the library, you must provide 40 | complete object files to the recipients so that they can relink them 41 | with the library, after making changes to the library and recompiling 42 | it. And you must show them these terms so they know their rights. 43 | 44 | Our method of protecting your rights has two steps: (1) copyright 45 | the library, and (2) offer you this license which gives you legal 46 | permission to copy, distribute and/or modify the library. 47 | 48 | Also, for each distributor's protection, we want to make certain 49 | that everyone understands that there is no warranty for this free 50 | library. If the library is modified by someone else and passed on, we 51 | want its recipients to know that what they have is not the original 52 | version, so that any problems introduced by others will not reflect on 53 | the original authors' reputations. 54 | 55 | Finally, any free program is threatened constantly by software 56 | patents. We wish to avoid the danger that companies distributing free 57 | software will individually obtain patent licenses, thus in effect 58 | transforming the program into proprietary software. To prevent this, 59 | we have made it clear that any patent must be licensed for everyone's 60 | free use or not licensed at all. 61 | 62 | Most GNU software, including some libraries, is covered by the ordinary 63 | GNU General Public License, which was designed for utility programs. This 64 | license, the GNU Library General Public License, applies to certain 65 | designated libraries. This license is quite different from the ordinary 66 | one; be sure to read it in full, and don't assume that anything in it is 67 | the same as in the ordinary license. 68 | 69 | The reason we have a separate public license for some libraries is that 70 | they blur the distinction we usually make between modifying or adding to a 71 | program and simply using it. Linking a program with a library, without 72 | changing the library, is in some sense simply using the library, and is 73 | analogous to running a utility program or application program. However, in 74 | a textual and legal sense, the linked executable is a combined work, a 75 | derivative of the original library, and the ordinary General Public License 76 | treats it as such. 77 | 78 | Because of this blurred distinction, using the ordinary General 79 | Public License for libraries did not effectively promote software 80 | sharing, because most developers did not use the libraries. We 81 | concluded that weaker conditions might promote sharing better. 82 | 83 | However, unrestricted linking of non-free programs would deprive the 84 | users of those programs of all benefit from the free status of the 85 | libraries themselves. This Library General Public License is intended to 86 | permit developers of non-free programs to use free libraries, while 87 | preserving your freedom as a user of such programs to change the free 88 | libraries that are incorporated in them. (We have not seen how to achieve 89 | this as regards changes in header files, but we have achieved it as regards 90 | changes in the actual functions of the Library.) The hope is that this 91 | will lead to faster development of free libraries. 92 | 93 | The precise terms and conditions for copying, distribution and 94 | modification follow. Pay close attention to the difference between a 95 | "work based on the library" and a "work that uses the library". The 96 | former contains code derived from the library, while the latter only 97 | works together with the library. 98 | 99 | Note that it is possible for a library to be covered by the ordinary 100 | General Public License rather than by this special one. 101 | 102 | GNU LIBRARY GENERAL PUBLIC LICENSE 103 | TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 104 | 105 | 0. This License Agreement applies to any software library which 106 | contains a notice placed by the copyright holder or other authorized 107 | party saying it may be distributed under the terms of this Library 108 | General Public License (also called "this License"). Each licensee is 109 | addressed as "you". 110 | 111 | A "library" means a collection of software functions and/or data 112 | prepared so as to be conveniently linked with application programs 113 | (which use some of those functions and data) to form executables. 114 | 115 | The "Library", below, refers to any such software library or work 116 | which has been distributed under these terms. A "work based on the 117 | Library" means either the Library or any derivative work under 118 | copyright law: that is to say, a work containing the Library or a 119 | portion of it, either verbatim or with modifications and/or translated 120 | straightforwardly into another language. (Hereinafter, translation is 121 | included without limitation in the term "modification".) 122 | 123 | "Source code" for a work means the preferred form of the work for 124 | making modifications to it. For a library, complete source code means 125 | all the source code for all modules it contains, plus any associated 126 | interface definition files, plus the scripts used to control compilation 127 | and installation of the library. 128 | 129 | Activities other than copying, distribution and modification are not 130 | covered by this License; they are outside its scope. The act of 131 | running a program using the Library is not restricted, and output from 132 | such a program is covered only if its contents constitute a work based 133 | on the Library (independent of the use of the Library in a tool for 134 | writing it). Whether that is true depends on what the Library does 135 | and what the program that uses the Library does. 136 | 137 | 1. You may copy and distribute verbatim copies of the Library's 138 | complete source code as you receive it, in any medium, provided that 139 | you conspicuously and appropriately publish on each copy an 140 | appropriate copyright notice and disclaimer of warranty; keep intact 141 | all the notices that refer to this License and to the absence of any 142 | warranty; and distribute a copy of this License along with the 143 | Library. 144 | 145 | You may charge a fee for the physical act of transferring a copy, 146 | and you may at your option offer warranty protection in exchange for a 147 | fee. 148 | 149 | 2. You may modify your copy or copies of the Library or any portion 150 | of it, thus forming a work based on the Library, and copy and 151 | distribute such modifications or work under the terms of Section 1 152 | above, provided that you also meet all of these conditions: 153 | 154 | a) The modified work must itself be a software library. 155 | 156 | b) You must cause the files modified to carry prominent notices 157 | stating that you changed the files and the date of any change. 158 | 159 | c) You must cause the whole of the work to be licensed at no 160 | charge to all third parties under the terms of this License. 161 | 162 | d) If a facility in the modified Library refers to a function or a 163 | table of data to be supplied by an application program that uses 164 | the facility, other than as an argument passed when the facility 165 | is invoked, then you must make a good faith effort to ensure that, 166 | in the event an application does not supply such function or 167 | table, the facility still operates, and performs whatever part of 168 | its purpose remains meaningful. 169 | 170 | (For example, a function in a library to compute square roots has 171 | a purpose that is entirely well-defined independent of the 172 | application. Therefore, Subsection 2d requires that any 173 | application-supplied function or table used by this function must 174 | be optional: if the application does not supply it, the square 175 | root function must still compute square roots.) 176 | 177 | These requirements apply to the modified work as a whole. If 178 | identifiable sections of that work are not derived from the Library, 179 | and can be reasonably considered independent and separate works in 180 | themselves, then this License, and its terms, do not apply to those 181 | sections when you distribute them as separate works. But when you 182 | distribute the same sections as part of a whole which is a work based 183 | on the Library, the distribution of the whole must be on the terms of 184 | this License, whose permissions for other licensees extend to the 185 | entire whole, and thus to each and every part regardless of who wrote 186 | it. 187 | 188 | Thus, it is not the intent of this section to claim rights or contest 189 | your rights to work written entirely by you; rather, the intent is to 190 | exercise the right to control the distribution of derivative or 191 | collective works based on the Library. 192 | 193 | In addition, mere aggregation of another work not based on the Library 194 | with the Library (or with a work based on the Library) on a volume of 195 | a storage or distribution medium does not bring the other work under 196 | the scope of this License. 197 | 198 | 3. You may opt to apply the terms of the ordinary GNU General Public 199 | License instead of this License to a given copy of the Library. To do 200 | this, you must alter all the notices that refer to this License, so 201 | that they refer to the ordinary GNU General Public License, version 2, 202 | instead of to this License. (If a newer version than version 2 of the 203 | ordinary GNU General Public License has appeared, then you can specify 204 | that version instead if you wish.) Do not make any other change in 205 | these notices. 206 | 207 | Once this change is made in a given copy, it is irreversible for 208 | that copy, so the ordinary GNU General Public License applies to all 209 | subsequent copies and derivative works made from that copy. 210 | 211 | This option is useful when you wish to copy part of the code of 212 | the Library into a program that is not a library. 213 | 214 | 4. You may copy and distribute the Library (or a portion or 215 | derivative of it, under Section 2) in object code or executable form 216 | under the terms of Sections 1 and 2 above provided that you accompany 217 | it with the complete corresponding machine-readable source code, which 218 | must be distributed under the terms of Sections 1 and 2 above on a 219 | medium customarily used for software interchange. 220 | 221 | If distribution of object code is made by offering access to copy 222 | from a designated place, then offering equivalent access to copy the 223 | source code from the same place satisfies the requirement to 224 | distribute the source code, even though third parties are not 225 | compelled to copy the source along with the object code. 226 | 227 | 5. A program that contains no derivative of any portion of the 228 | Library, but is designed to work with the Library by being compiled or 229 | linked with it, is called a "work that uses the Library". Such a 230 | work, in isolation, is not a derivative work of the Library, and 231 | therefore falls outside the scope of this License. 232 | 233 | However, linking a "work that uses the Library" with the Library 234 | creates an executable that is a derivative of the Library (because it 235 | contains portions of the Library), rather than a "work that uses the 236 | library". The executable is therefore covered by this License. 237 | Section 6 states terms for distribution of such executables. 238 | 239 | When a "work that uses the Library" uses material from a header file 240 | that is part of the Library, the object code for the work may be a 241 | derivative work of the Library even though the source code is not. 242 | Whether this is true is especially significant if the work can be 243 | linked without the Library, or if the work is itself a library. The 244 | threshold for this to be true is not precisely defined by law. 245 | 246 | If such an object file uses only numerical parameters, data 247 | structure layouts and accessors, and small macros and small inline 248 | functions (ten lines or less in length), then the use of the object 249 | file is unrestricted, regardless of whether it is legally a derivative 250 | work. (Executables containing this object code plus portions of the 251 | Library will still fall under Section 6.) 252 | 253 | Otherwise, if the work is a derivative of the Library, you may 254 | distribute the object code for the work under the terms of Section 6. 255 | Any executables containing that work also fall under Section 6, 256 | whether or not they are linked directly with the Library itself. 257 | 258 | 6. As an exception to the Sections above, you may also compile or 259 | link a "work that uses the Library" with the Library to produce a 260 | work containing portions of the Library, and distribute that work 261 | under terms of your choice, provided that the terms permit 262 | modification of the work for the customer's own use and reverse 263 | engineering for debugging such modifications. 264 | 265 | You must give prominent notice with each copy of the work that the 266 | Library is used in it and that the Library and its use are covered by 267 | this License. You must supply a copy of this License. If the work 268 | during execution displays copyright notices, you must include the 269 | copyright notice for the Library among them, as well as a reference 270 | directing the user to the copy of this License. Also, you must do one 271 | of these things: 272 | 273 | a) Accompany the work with the complete corresponding 274 | machine-readable source code for the Library including whatever 275 | changes were used in the work (which must be distributed under 276 | Sections 1 and 2 above); and, if the work is an executable linked 277 | with the Library, with the complete machine-readable "work that 278 | uses the Library", as object code and/or source code, so that the 279 | user can modify the Library and then relink to produce a modified 280 | executable containing the modified Library. (It is understood 281 | that the user who changes the contents of definitions files in the 282 | Library will not necessarily be able to recompile the application 283 | to use the modified definitions.) 284 | 285 | b) Accompany the work with a written offer, valid for at 286 | least three years, to give the same user the materials 287 | specified in Subsection 6a, above, for a charge no more 288 | than the cost of performing this distribution. 289 | 290 | c) If distribution of the work is made by offering access to copy 291 | from a designated place, offer equivalent access to copy the above 292 | specified materials from the same place. 293 | 294 | d) Verify that the user has already received a copy of these 295 | materials or that you have already sent this user a copy. 296 | 297 | For an executable, the required form of the "work that uses the 298 | Library" must include any data and utility programs needed for 299 | reproducing the executable from it. However, as a special exception, 300 | the source code distributed need not include anything that is normally 301 | distributed (in either source or binary form) with the major 302 | components (compiler, kernel, and so on) of the operating system on 303 | which the executable runs, unless that component itself accompanies 304 | the executable. 305 | 306 | It may happen that this requirement contradicts the license 307 | restrictions of other proprietary libraries that do not normally 308 | accompany the operating system. Such a contradiction means you cannot 309 | use both them and the Library together in an executable that you 310 | distribute. 311 | 312 | 7. You may place library facilities that are a work based on the 313 | Library side-by-side in a single library together with other library 314 | facilities not covered by this License, and distribute such a combined 315 | library, provided that the separate distribution of the work based on 316 | the Library and of the other library facilities is otherwise 317 | permitted, and provided that you do these two things: 318 | 319 | a) Accompany the combined library with a copy of the same work 320 | based on the Library, uncombined with any other library 321 | facilities. This must be distributed under the terms of the 322 | Sections above. 323 | 324 | b) Give prominent notice with the combined library of the fact 325 | that part of it is a work based on the Library, and explaining 326 | where to find the accompanying uncombined form of the same work. 327 | 328 | 8. You may not copy, modify, sublicense, link with, or distribute 329 | the Library except as expressly provided under this License. Any 330 | attempt otherwise to copy, modify, sublicense, link with, or 331 | distribute the Library is void, and will automatically terminate your 332 | rights under this License. However, parties who have received copies, 333 | or rights, from you under this License will not have their licenses 334 | terminated so long as such parties remain in full compliance. 335 | 336 | 9. You are not required to accept this License, since you have not 337 | signed it. However, nothing else grants you permission to modify or 338 | distribute the Library or its derivative works. These actions are 339 | prohibited by law if you do not accept this License. Therefore, by 340 | modifying or distributing the Library (or any work based on the 341 | Library), you indicate your acceptance of this License to do so, and 342 | all its terms and conditions for copying, distributing or modifying 343 | the Library or works based on it. 344 | 345 | 10. Each time you redistribute the Library (or any work based on the 346 | Library), the recipient automatically receives a license from the 347 | original licensor to copy, distribute, link with or modify the Library 348 | subject to these terms and conditions. You may not impose any further 349 | restrictions on the recipients' exercise of the rights granted herein. 350 | You are not responsible for enforcing compliance by third parties to 351 | this License. 352 | 353 | 11. If, as a consequence of a court judgment or allegation of patent 354 | infringement or for any other reason (not limited to patent issues), 355 | conditions are imposed on you (whether by court order, agreement or 356 | otherwise) that contradict the conditions of this License, they do not 357 | excuse you from the conditions of this License. If you cannot 358 | distribute so as to satisfy simultaneously your obligations under this 359 | License and any other pertinent obligations, then as a consequence you 360 | may not distribute the Library at all. For example, if a patent 361 | license would not permit royalty-free redistribution of the Library by 362 | all those who receive copies directly or indirectly through you, then 363 | the only way you could satisfy both it and this License would be to 364 | refrain entirely from distribution of the Library. 365 | 366 | If any portion of this section is held invalid or unenforceable under any 367 | particular circumstance, the balance of the section is intended to apply, 368 | and the section as a whole is intended to apply in other circumstances. 369 | 370 | It is not the purpose of this section to induce you to infringe any 371 | patents or other property right claims or to contest validity of any 372 | such claims; this section has the sole purpose of protecting the 373 | integrity of the free software distribution system which is 374 | implemented by public license practices. Many people have made 375 | generous contributions to the wide range of software distributed 376 | through that system in reliance on consistent application of that 377 | system; it is up to the author/donor to decide if he or she is willing 378 | to distribute software through any other system and a licensee cannot 379 | impose that choice. 380 | 381 | This section is intended to make thoroughly clear what is believed to 382 | be a consequence of the rest of this License. 383 | 384 | 12. If the distribution and/or use of the Library is restricted in 385 | certain countries either by patents or by copyrighted interfaces, the 386 | original copyright holder who places the Library under this License may add 387 | an explicit geographical distribution limitation excluding those countries, 388 | so that distribution is permitted only in or among countries not thus 389 | excluded. In such case, this License incorporates the limitation as if 390 | written in the body of this License. 391 | 392 | 13. The Free Software Foundation may publish revised and/or new 393 | versions of the Library General Public License from time to time. 394 | Such new versions will be similar in spirit to the present version, 395 | but may differ in detail to address new problems or concerns. 396 | 397 | Each version is given a distinguishing version number. If the Library 398 | specifies a version number of this License which applies to it and 399 | "any later version", you have the option of following the terms and 400 | conditions either of that version or of any later version published by 401 | the Free Software Foundation. If the Library does not specify a 402 | license version number, you may choose any version ever published by 403 | the Free Software Foundation. 404 | 405 | 14. If you wish to incorporate parts of the Library into other free 406 | programs whose distribution conditions are incompatible with these, 407 | write to the author to ask for permission. For software which is 408 | copyrighted by the Free Software Foundation, write to the Free 409 | Software Foundation; we sometimes make exceptions for this. Our 410 | decision will be guided by the two goals of preserving the free status 411 | of all derivatives of our free software and of promoting the sharing 412 | and reuse of software generally. 413 | 414 | NO WARRANTY 415 | 416 | 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO 417 | WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. 418 | EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR 419 | OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY 420 | KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE 421 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 422 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE 423 | LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME 424 | THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 425 | 426 | 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN 427 | WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY 428 | AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU 429 | FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR 430 | CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE 431 | LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING 432 | RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A 433 | FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF 434 | SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH 435 | DAMAGES. 436 | 437 | END OF TERMS AND CONDITIONS 438 | 439 | Appendix: How to Apply These Terms to Your New Libraries 440 | 441 | If you develop a new library, and you want it to be of the greatest 442 | possible use to the public, we recommend making it free software that 443 | everyone can redistribute and change. You can do so by permitting 444 | redistribution under these terms (or, alternatively, under the terms of the 445 | ordinary General Public License). 446 | 447 | To apply these terms, attach the following notices to the library. It is 448 | safest to attach them to the start of each source file to most effectively 449 | convey the exclusion of warranty; and each file should have at least the 450 | "copyright" line and a pointer to where the full notice is found. 451 | 452 | 453 | Copyright (C) 454 | 455 | This library is free software; you can redistribute it and/or 456 | modify it under the terms of the GNU Library General Public 457 | License as published by the Free Software Foundation; either 458 | version 2 of the License, or (at your option) any later version. 459 | 460 | This library is distributed in the hope that it will be useful, 461 | but WITHOUT ANY WARRANTY; without even the implied warranty of 462 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 463 | Library General Public License for more details. 464 | 465 | You should have received a copy of the GNU Library General Public 466 | License along with this library; if not, write to the Free 467 | Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 468 | 469 | Also add information on how to contact you by electronic and paper mail. 470 | 471 | You should also get your employer (if you work as a programmer) or your 472 | school, if any, to sign a "copyright disclaimer" for the library, if 473 | necessary. Here is a sample; alter the names: 474 | 475 | Yoyodyne, Inc., hereby disclaims all copyright interest in the 476 | library `Frob' (a library for tweaking knobs) written by James Random Hacker. 477 | 478 | , 1 April 1990 479 | Ty Coon, President of Vice 480 | 481 | That's all there is to it! 482 | -------------------------------------------------------------------------------- /INSTALL: -------------------------------------------------------------------------------- 1 | Columbo Simple Serial Library 2 | http://cssl.sourceforge.net 3 | Copyright 2003 Marcin Siennicki m.siennicki@cloos.pl 4 | see COPYING file for details 5 | 6 | 7 | To compile install this you will need libtool and 8 | GNU make. If you got it, just cd to libcssl directory, 9 | look into Makefile - you can change destination directory 10 | for the library files (it is set to /usr/lib), then type: 11 | 12 | $ make 13 | 14 | --Note for RedHat and other RPM systems users---------- 15 | If you like to create RPM files: edit Makefile - it is 16 | configured for RedHat. Change SRPMPATH, RPMPATH, 17 | SRPMNAME and RPMNAME to proper settings (you don't 18 | need to do it under RedHat or Aurox). Then run: 19 | 20 | $ make rpm 21 | 22 | or (if you haven't privileges to /usr/src/redhat dirs): 23 | 24 | $ su 25 | Password: 26 | # make rpm 27 | 28 | the rpms should appear in the source directory. 29 | ------------------------------------------------------ 30 | 31 | I everything was ok then you can test it. Connect 32 | your serial port (ttyS0) to other one - it can be 33 | a character terminal, other machine or just your 34 | second serial port (ttyS0). If the remote device is a pc 35 | then run a terminal emulator on it (for example minicom). 36 | Configure remote device's serial port as follows: 37 | 38 | baudrate: 19200 39 | data bits: 8 40 | parity: none 41 | stop bits: 1 42 | flow control: none 43 | 44 | Then run: 45 | 46 | $ ./test 47 | 48 | If there's file access error, try: 49 | 50 | $ su 51 | Password: 52 | # ./test 53 | 54 | Now it should be everything OK. 55 | 56 | You should see a text on the remote device. Type some 57 | text on the remote keyboard. You should see it on your 58 | linux screen. Ctrl-D on the remote or Ctrl-C on local 59 | machine finishes program. 60 | 61 | If it did work, type: 62 | 63 | # make install, 64 | 65 | or, for rpm users: 66 | 67 | # rpm -Uhv 68 | (for example: # rpm -Uhv libcssl-0.9.3-1.i386.rpm) 69 | 70 | Now check if shared linking works: 71 | 72 | $ make test.shared 73 | $ ./test.shared 74 | 75 | And then you can compile your programs against libcssl. 76 | Don't forget to read README file. If you find the library 77 | useful, and you realy use it - please let me know about it. 78 | 79 | If it didn't work, feel free to email me and describe the 80 | problem. 81 | 82 | Marcin Siennicki 83 | m.siennicki@cloos.pl 84 | 85 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | # Copyright 2003 Marcin Siennicki 2 | # see COPYING file for details 3 | 4 | VERSION = 0 5 | REVISION = 9 6 | MINOR = 4 7 | AGE = 0 8 | 9 | FULLVERSION = $(VERSION).$(REVISION).$(MINOR) 10 | 11 | DISTNAME = libcssl-$(FULLVERSION) 12 | 13 | SOURCEFILES = Makefile README INSTALL COPYING \ 14 | test.c cssl.c cssl.h libcssl.spec libcssl.spec.in 15 | 16 | SRPMPATH = /usr/src/redhat/SRPMS 17 | 18 | RPMPATH = /usr/src/redhat/RPMS/i386 19 | 20 | SRPMNAME = $(DISTNAME)-1.src.rpm 21 | 22 | RPMNAME = $(DISTNAME)-1.i386.rpm 23 | 24 | ifndef PREFIX 25 | PREFIX = /usr 26 | endif 27 | 28 | LIBPATH = $(PREFIX)/lib 29 | INCLUDEPATH = $(PREFIX)/include 30 | PKGCONFIGPATH = $(PREFIX)/lib/pkgconfig 31 | 32 | all: libcssl.la test libcssl.pc 33 | 34 | cssl.lo: cssl.c Makefile 35 | libtool gcc -Wall -D_GNU_SOURCE -g -O -c cssl.c 36 | 37 | libcssl.la: cssl.lo 38 | libtool gcc -g -O -o libcssl.la -rpath $(LIBPATH)\ 39 | -version-info $(VERSION):$(REVISION):$(AGE)\ 40 | cssl.lo 41 | 42 | test.o: test.c 43 | libtool gcc -Wall -D_GNU_SOURCE -g -O -c test.c 44 | 45 | test: test.o libcssl.la 46 | libtool gcc -g -O -o test test.o libcssl.la 47 | 48 | test.shared: test.c 49 | gcc -g -O -o test.shared test.c -lcssl 50 | 51 | install: libcssl.la cssl.h libcssl.pc 52 | install -d $(LIBPATH) $(INCLUDEPATH) $(PKGCONFIGPATH) 53 | libtool install -c libcssl.la $(LIBPATH) 54 | install -c cssl.h $(INCLUDEPATH) 55 | install -c libcssl.pc $(PKGCONFIGPATH) 56 | 57 | dist: libcssl.spec 58 | rm -rf $(DISTNAME) 59 | mkdir $(DISTNAME) 60 | for i in $(SOURCEFILES) ; { ln $$i $(DISTNAME)/$$i ; } 61 | tar -czf $(DISTNAME).tar.gz $(DISTNAME) 62 | 63 | libcssl.spec: Makefile libcssl.spec.in 64 | m4 -D____CSSL_VERSION____=$(FULLVERSION) libcssl.spec.in > libcssl.spec 65 | 66 | libcssl.pc: Makefile 67 | echo "prefix=$(PREFIX)" > $@ 68 | echo "exec_prefix=$(PREFIX)" >> $@ 69 | echo "libdir=$(LIBPATH)">> $@ 70 | echo "includedir=$(INCLUDEPATH)" >> $@ 71 | echo "" >> $@ 72 | echo "Name: libcssl-$(VERSION).$(REVISION)" >> $@ 73 | echo "Description: a serial port communication library" >> $@ 74 | echo "Version: $(VERSION).$(REVISION).$(MINOR)" >> $@ 75 | echo "Libs: -L\$${libdir} -lcssl" >> $@ 76 | echo "Cflags: -I\$${includedir}" >> $@ 77 | 78 | rpm: dist 79 | rpmbuild -ta $(DISTNAME).tar.gz 80 | mv $(SRPMPATH)/$(SRPMNAME) . 81 | mv $(RPMPATH)/$(RPMNAME) . 82 | 83 | clean: 84 | rm -fr .libs test test.shared *.la *.lo *.o *~ $(DISTNAME) *.gz *.rpm libcssl.spec 85 | -------------------------------------------------------------------------------- /README: -------------------------------------------------------------------------------- 1 | This is a short description of Columbo Simple Serial Library. 2 | http://cssl.sourceforge.net 3 | 4 | 1) Installing libcssl 5 | 6 | 2) Compiling and linking your applications against libcssl 7 | 8 | 3) Using libcssl 9 | 10 | - Event driven mode 11 | a) callback function 12 | b) starting 13 | c) openig ports 14 | d) setting flow cotrol 15 | e) sending data 16 | f) receiving data 17 | g) changing port setup 18 | h) errors 19 | i) finishing 20 | 21 | - Blocking mode 22 | a) notes 23 | b) setting the timeout value 24 | c) receiving data 25 | 26 | =========================================================== 27 | 1) Installing libcssl 28 | Read INSTALL file 29 | 30 | =========================================================== 31 | 2) Compiling and linking your applications against libcssl 32 | 33 | First, in your C files you should include libcssl.h: 34 | 35 | #include 36 | 37 | To compile and link your program against libcssl do for 38 | example as follows: 39 | 40 | $ gcc -Wall -O -o my_program my_program.c -lcssl 41 | 42 | You can use pkg-config too: 43 | 44 | $ -Wall -O -o my_program `pkg-config --cflags --libs libcssl` my_program.c 45 | =========================================================== 46 | 3) Using libcssl 47 | 48 | - Event driven mode 49 | a) write a callback function, for example: 50 | 51 | void callback_function(int id, unit8_t *buf, int buflen) 52 | { 53 | int i; 54 | for(i=0;i 2 | * see COPYING file for details */ 3 | 4 | #include 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | #include "cssl.h" 16 | 17 | /* 18 | * Static variables and constants 19 | */ 20 | 21 | /* signal number for serial i/o read */ 22 | static int CSSL_SIGNAL=0; 23 | 24 | /* boolean that say if we have started cssl */ 25 | static int cssl_started=0; 26 | 27 | /* sigactions */ 28 | static struct sigaction sa; 29 | static struct sigaction oldsa; 30 | 31 | /* head of the cssl_t list */ 32 | static cssl_t *head=0; 33 | 34 | /* error messages table */ 35 | static const char *cssl_errors[]= { 36 | "cssl: OK", 37 | "cssl: there's no free signal", 38 | "cssl: not started", 39 | "cssl: null pointer", 40 | "cssl: oops", 41 | "cssl: out of memory", 42 | "cssl: cannot open file" 43 | }; 44 | 45 | /* status of last cssl function */ 46 | static cssl_error_t cssl_error=CSSL_OK; 47 | 48 | /* prototype of signal handler */ 49 | static void cssl_handler(int signo, siginfo_t *info, void *ignored); 50 | 51 | 52 | /************************************** 53 | * Public functions 54 | **************************************/ 55 | 56 | /*------------------------------------- 57 | * Error handling 58 | */ 59 | 60 | /* gets the last operation status message */ 61 | const char *cssl_geterrormsg() 62 | { 63 | return cssl_errors[cssl_error]; 64 | } 65 | 66 | 67 | /* gets the last error code */ 68 | int cssl_geterror() 69 | { 70 | return cssl_error; 71 | } 72 | 73 | /*------------------------------------- 74 | * Startig/stoping cssl 75 | */ 76 | 77 | /* starts cssl */ 78 | void cssl_start() 79 | { 80 | int sig; 81 | 82 | if (cssl_started) { 83 | return; 84 | } 85 | 86 | /* Here we scan for unused real time signal */ 87 | sig=SIGRTMIN; 88 | 89 | do { 90 | 91 | /* get old sigaction */ 92 | sigaction(sig,0,&oldsa); 93 | 94 | /* if signal's handler is empty */ 95 | if (oldsa.sa_handler == 0) 96 | { 97 | /* set the signal handler, and others */ 98 | CSSL_SIGNAL=sig; 99 | sa.sa_sigaction = cssl_handler; 100 | sa.sa_flags = SA_SIGINFO; 101 | sa.sa_restorer = NULL; 102 | sigemptyset(&sa.sa_mask); 103 | sigaction(CSSL_SIGNAL,&sa,0); 104 | 105 | /* OK, the cssl is started */ 106 | cssl_started=1; 107 | cssl_error=CSSL_OK; 108 | return; 109 | } else { 110 | /* signal handler was not empty, 111 | restore original */ 112 | sigaction(CSSL_SIGNAL,&oldsa,0); 113 | } 114 | sig++; 115 | } while(sig<=SIGRTMAX); 116 | 117 | 118 | /* Sorry, there's no free signal */ 119 | cssl_error=CSSL_ERROR_NOSIGNAL; 120 | 121 | } 122 | 123 | /* stops the cssl */ 124 | void cssl_stop() 125 | { 126 | /* if not started we do nothing */ 127 | if (!cssl_started) 128 | return; 129 | 130 | /* we close all ports, and free the list */ 131 | while (head) 132 | cssl_close(head); 133 | 134 | /* then we remove the signal handler */ 135 | sigaction(CSSL_SIGNAL,&oldsa,NULL); 136 | 137 | /* And at least : */ 138 | cssl_started=0; 139 | cssl_error=CSSL_OK; 140 | } 141 | 142 | /*------------------------------------- 143 | * Basic port operation - open/close 144 | */ 145 | 146 | 147 | /* opens the port */ 148 | cssl_t *cssl_open(const char *fname, 149 | cssl_callback_t callback, 150 | int id, 151 | int baud, 152 | int bits, 153 | int parity, 154 | int stop) 155 | { 156 | cssl_t *serial; 157 | 158 | if (!cssl_started) { 159 | cssl_error=CSSL_ERROR_NOTSTARTED; 160 | return NULL; 161 | } 162 | 163 | /* create new cssl_t structure */ 164 | serial=calloc(1,sizeof(cssl_t)); 165 | 166 | /* oops, no memory */ 167 | if (!serial) { 168 | cssl_error=CSSL_ERROR_MEMORY; 169 | return 0; 170 | } 171 | 172 | /* opening the file */ 173 | if(callback) { 174 | /* user wants event driven reading */ 175 | serial->fd=open(fname,O_RDWR|O_NOCTTY|O_NONBLOCK); 176 | fcntl(serial->fd,F_SETSIG,CSSL_SIGNAL); 177 | fcntl(serial->fd,F_SETOWN,getpid()); 178 | fcntl(serial->fd,F_SETFL,O_ASYNC|O_NONBLOCK); 179 | } else { 180 | /* the read/write operations will be bloking */ 181 | serial->fd=open(fname,O_RDWR|O_NOCTTY); 182 | } 183 | 184 | /* oops, cannot open */ 185 | if (serial->fd == -1) { 186 | cssl_error=CSSL_ERROR_OPEN; 187 | free(serial); 188 | return NULL; 189 | } 190 | 191 | /* we remember old termios */ 192 | tcgetattr(serial->fd,&(serial->oldtio)); 193 | 194 | /* now we set new values */ 195 | cssl_setup(serial,baud,parity,bits,stop); 196 | 197 | /* and id */ 198 | serial->id=id; 199 | 200 | /* then set the callback */ 201 | serial->callback=callback; 202 | 203 | /* we add the serial to our list */ 204 | serial->next=head; 205 | head=serial; 206 | 207 | cssl_error=CSSL_OK; 208 | 209 | return serial; 210 | } 211 | 212 | 213 | /* closes file, removes serial from the list and frees it */ 214 | void cssl_close(cssl_t *serial) 215 | { 216 | cssl_t *cur; 217 | 218 | if (!cssl_started) { 219 | cssl_error=CSSL_ERROR_NOTSTARTED; 220 | return; 221 | } 222 | 223 | if (!serial) { 224 | cssl_error=CSSL_ERROR_NULLPOINTER; 225 | return; 226 | } 227 | 228 | /* first we flush the port */ 229 | tcflush(serial->fd,TCOFLUSH); 230 | tcflush(serial->fd,TCIFLUSH); 231 | 232 | /* then we restore old settings */ 233 | tcsetattr(serial->fd,TCSANOW,&(serial->oldtio)); 234 | 235 | /* and close the file */ 236 | close(serial->fd); 237 | 238 | /* now we can remove the serial from the list */ 239 | 240 | if (head==serial) { 241 | head=serial->next; 242 | free(serial); 243 | cssl_error=CSSL_OK; 244 | return; 245 | } 246 | 247 | for (cur=head;cur;cur=cur->next) { 248 | if (cur->next==serial) { 249 | cur->next=serial->next; 250 | free(serial); 251 | cssl_error=CSSL_OK; 252 | return; 253 | } 254 | } 255 | 256 | /* we should never reach there, 257 | it means, that serial was not found in the list */ 258 | cssl_error=CSSL_ERROR_OOPS; 259 | } 260 | 261 | 262 | /*------------------------------------- 263 | * Port setup 264 | */ 265 | 266 | /* sets up the port parameters */ 267 | void cssl_setup(cssl_t *serial, 268 | int baud, 269 | int bits, 270 | int parity, 271 | int stop) 272 | { 273 | tcflag_t baudrate; 274 | tcflag_t databits; 275 | tcflag_t stopbits; 276 | tcflag_t checkparity; 277 | 278 | if (!cssl_started) { 279 | cssl_error=CSSL_ERROR_NOTSTARTED; 280 | return; 281 | } 282 | 283 | if (!serial) { 284 | cssl_error=CSSL_ERROR_NULLPOINTER; 285 | return; 286 | } 287 | 288 | /* get the propr baudrate */ 289 | switch (baud) { 290 | case 75: 291 | baudrate=B75; 292 | break; 293 | case 110: 294 | baudrate=B110; 295 | break; 296 | case 150: 297 | baudrate=B150; 298 | break; 299 | case 300: 300 | baudrate=B300; 301 | break; 302 | case 600: 303 | baudrate=B600; 304 | break; 305 | case 1200: 306 | baudrate=B1200; 307 | break; 308 | case 2400: 309 | baudrate=B2400; 310 | break; 311 | case 4800: 312 | baudrate=B4800; 313 | break; 314 | case 9600: 315 | baudrate=B9600; 316 | break; 317 | case 19200: 318 | baudrate=B19200; 319 | break; 320 | case 38400: 321 | baudrate=B38400; 322 | break; 323 | case 57600: 324 | baudrate=B57600; 325 | break; 326 | case 115200: 327 | baudrate=B115200; 328 | break; 329 | default: 330 | baudrate=B9600; 331 | } 332 | 333 | /* databits */ 334 | switch (bits) { 335 | case 7: 336 | databits=CS7; 337 | break; 338 | case 8: 339 | databits=CS8; 340 | break; 341 | default: 342 | databits=CS8; 343 | } 344 | 345 | /* parity, */ 346 | switch (parity) { 347 | case 0: 348 | checkparity=0; 349 | break; 350 | case 1: //odd 351 | checkparity=PARENB|PARODD; 352 | break; 353 | case 2: 354 | checkparity=PARENB; 355 | break; 356 | default: 357 | checkparity=0; 358 | } 359 | 360 | /* and stop bits */ 361 | switch (stop) { 362 | case 1: 363 | stopbits=0; 364 | break; 365 | case 2: 366 | stopbits=CSTOPB; 367 | break; 368 | default: 369 | stopbits=0; 370 | } 371 | 372 | /* now we setup the values in port's termios */ 373 | serial->tio.c_cflag=baudrate|databits|checkparity|stopbits|CLOCAL|CREAD; 374 | serial->tio.c_iflag=IGNPAR; 375 | serial->tio.c_oflag=0; 376 | serial->tio.c_lflag=0; 377 | serial->tio.c_cc[VMIN]=1; 378 | serial->tio.c_cc[VTIME]=0; 379 | 380 | /* we flush the port */ 381 | tcflush(serial->fd,TCOFLUSH); 382 | tcflush(serial->fd,TCIFLUSH); 383 | 384 | /* we send new config to the port */ 385 | tcsetattr(serial->fd,TCSANOW,&(serial->tio)); 386 | 387 | cssl_error=CSSL_OK; 388 | } 389 | 390 | void cssl_setflowcontrol(cssl_t *serial, 391 | int rtscts, 392 | int xonxoff) 393 | { 394 | if (!cssl_started) { 395 | cssl_error=CSSL_ERROR_NOTSTARTED; 396 | return; 397 | } 398 | 399 | if (!serial) { 400 | cssl_error=CSSL_ERROR_NULLPOINTER; 401 | return; 402 | } 403 | 404 | /* We setup rts/cts (hardware) flow control */ 405 | if (rtscts) { 406 | serial->tio.c_cflag |= CRTSCTS; 407 | } else { 408 | serial->tio.c_cflag &= ~CRTSCTS; 409 | } 410 | 411 | /* We setup xon/xoff (soft) flow control */ 412 | if (xonxoff) { 413 | serial->tio.c_iflag |= (IXON|IXOFF); 414 | } else { 415 | serial->tio.c_iflag &= ~(IXON|IXOFF); 416 | } 417 | 418 | tcsetattr(serial->fd,TCSANOW,&(serial->tio)); 419 | 420 | cssl_error=CSSL_OK; 421 | } 422 | 423 | 424 | 425 | /* Blocking mode: sets the timeout in 426 | hundreds of miliseconds */ 427 | void cssl_settimeout(cssl_t *serial, int timeout) 428 | { 429 | if (!cssl_started) { 430 | cssl_error=CSSL_ERROR_NOTSTARTED; 431 | return; 432 | } 433 | 434 | if (!serial) { 435 | cssl_error=CSSL_ERROR_NULLPOINTER; 436 | return; 437 | } 438 | 439 | serial->tio.c_cc[VTIME]=timeout; 440 | 441 | tcsetattr(serial->fd,TCSANOW,&(serial->tio)); 442 | 443 | cssl_error=CSSL_OK; 444 | } 445 | 446 | 447 | /*------------------------------------- 448 | * Serial communication 449 | */ 450 | 451 | /* sending a char */ 452 | void cssl_putchar(cssl_t *serial, 453 | char c) 454 | { 455 | if (!cssl_started) { 456 | cssl_error=CSSL_ERROR_NOTSTARTED; 457 | return; 458 | } 459 | 460 | if (!serial) { 461 | cssl_error=CSSL_ERROR_NULLPOINTER; 462 | return; 463 | } 464 | 465 | write(serial->fd,&c,1); 466 | } 467 | 468 | /* sending a null-terminated string */ 469 | void cssl_putstring(cssl_t *serial, 470 | char *str) 471 | { 472 | if (!cssl_started) { 473 | cssl_error=CSSL_ERROR_NOTSTARTED; 474 | return; 475 | } 476 | 477 | if (!serial) { 478 | cssl_error=CSSL_ERROR_NULLPOINTER; 479 | return; 480 | } 481 | write(serial->fd,str,strlen(str)); 482 | } 483 | 484 | 485 | /* sending a data of known size */ 486 | void cssl_putdata(cssl_t *serial, 487 | uint8_t *data, 488 | int datalen) 489 | { 490 | if (!cssl_started) { 491 | cssl_error=CSSL_ERROR_NOTSTARTED; 492 | return; 493 | } 494 | 495 | if (!serial) { 496 | cssl_error=CSSL_ERROR_NULLPOINTER; 497 | return; 498 | } 499 | 500 | write(serial->fd,data,datalen); 501 | } 502 | 503 | void cssl_drain(cssl_t *serial) 504 | { 505 | if (!cssl_started) { 506 | cssl_error=CSSL_ERROR_NOTSTARTED; 507 | return; 508 | } 509 | 510 | if (!serial) { 511 | cssl_error=CSSL_ERROR_NULLPOINTER; 512 | return; 513 | } 514 | 515 | tcdrain(serial->fd); 516 | } 517 | 518 | /* blocking mode: reading a char */ 519 | int cssl_getchar(cssl_t *serial) 520 | { 521 | int result; 522 | uint8_t c; 523 | 524 | result=read(serial->fd,&c,sizeof(c)); 525 | if (result<=0) 526 | return -1; 527 | 528 | return c; 529 | } 530 | 531 | /* blocking mode: reading a data buffer */ 532 | int cssl_getdata(cssl_t *serial, 533 | uint8_t *buffer, 534 | int size) 535 | { 536 | return read(serial->fd,buffer,size); 537 | } 538 | 539 | /*------------------------------------------*/ 540 | 541 | /* The most important: signal handler */ 542 | void cssl_handler(int signo, siginfo_t *info, void *ignored) 543 | { 544 | cssl_t *cur; 545 | int n; 546 | 547 | /* is this signal which says about 548 | incoming of the data? */ 549 | if (info->si_code==POLL_IN) { 550 | 551 | /* Yes, we got some data */ 552 | for(cur=head;cur;cur=cur->next) { 553 | 554 | /* Let's find proper cssl_t */ 555 | if (cur->fd==info->si_fd) { 556 | 557 | /* Got it */ 558 | n=read(cur->fd,cur->buffer,255); 559 | 560 | /* Execute callback */ 561 | if ((n>0)&&(cur->callback)) 562 | cur->callback(cur->id,cur->buffer,n); 563 | return; 564 | } 565 | } 566 | } 567 | } 568 | 569 | 570 | -------------------------------------------------------------------------------- /cssl.h: -------------------------------------------------------------------------------- 1 | /* Copyright 2003 Marcin Siennicki 2 | * see COPYING file for details */ 3 | 4 | #ifndef __CSSL_H__ 5 | #define __CSSL_H__ 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | 12 | typedef void (*cssl_callback_t)(int id, /* id passed to callback */ 13 | uint8_t *buffer, /* data received */ 14 | int len); /* length of data in bytes */ 15 | 16 | typedef struct __cssl_t { 17 | 18 | uint8_t buffer[255]; /* input buffer */ 19 | 20 | int fd; /* tty file descriptor */ 21 | 22 | struct termios tio; /* termios structure for the port */ 23 | struct termios oldtio; /* old termios structure */ 24 | 25 | cssl_callback_t callback; /* callback function */ 26 | 27 | int id; /* id which would be passed to callback */ 28 | 29 | struct __cssl_t *next; 30 | 31 | } cssl_t; 32 | 33 | typedef enum { 34 | CSSL_OK, /* everything is all right */ 35 | CSSL_ERROR_NOSIGNAL, /* there's no free signal */ 36 | CSSL_ERROR_NOTSTARTED, /* you should first start cssl */ 37 | CSSL_ERROR_NULLPOINTER, /* you gave a null pointer to the function */ 38 | CSSL_ERROR_OOPS, /* internal error, something's erong */ 39 | CSSL_ERROR_MEMORY, /* there's no memory for cssl_t structure */ 40 | CSSL_ERROR_OPEN /* file doesnt exist or you aren't good user */ 41 | } cssl_error_t; 42 | 43 | /* get the error message */ 44 | const char *cssl_geterrormsg(); 45 | 46 | /* get the error code */ 47 | int cssl_geterror(); 48 | 49 | /* start the cssl */ 50 | void cssl_start(); 51 | 52 | /* finish all jobs, clear memory, etc. */ 53 | void cssl_stop(); 54 | 55 | /* alloc new cssl_t struct and open the port */ 56 | cssl_t *cssl_open(const char *fname, /* pathname of port file, 57 | * for example "/dev/ttyS0" */ 58 | cssl_callback_t callback, /* callback function 59 | * If you dont want 60 | * event driven reading - set 61 | * it to NULL */ 62 | int id, /* your own id for the port, it can help 63 | * to identify the port in callback f.*/ 64 | int baud, /* baudrate, integer, for example 19200 */ 65 | int bits, /* data bits: 7 or 8 */ 66 | int parity, /* parity: 0 - none, 1-odd, 2-even */ 67 | int stop); /* stop bits: 1 or 2 */ 68 | 69 | /* closes the port, and frees its cssl_t struct */ 70 | void cssl_close(cssl_t *serial); 71 | 72 | /* setups the port, look at cssl_open */ 73 | void cssl_setup(cssl_t *serial, 74 | int baud, 75 | int bits, 76 | int parity, 77 | int stop); 78 | 79 | void cssl_setflowcontrol(cssl_t *serial, 80 | int rtscts, /* Boolean: 81 | * 0 - no rts/cts control, 82 | * 1 - rts/cts control 83 | */ 84 | int xonxoff); /* Boolean: 85 | * 0 - no xon/xoff, 86 | * 1 - xon/xoff 87 | */ 88 | 89 | /* sends a char via serial port */ 90 | void cssl_putchar(cssl_t *serial, 91 | char c); 92 | 93 | /* sends a null terminated string */ 94 | void cssl_putstring(cssl_t *serial, 95 | char *str); 96 | 97 | /* sends a data of known size */ 98 | void cssl_putdata(cssl_t *serial, 99 | uint8_t *data, /* data */ 100 | int datalen); /* length of data */ 101 | 102 | /* waits until all data has been transmited */ 103 | 104 | void cssl_drain(cssl_t *serial); 105 | 106 | /*====================================== 107 | * Blocking mode 108 | */ 109 | 110 | /* Sets port timeout (deciseconds) in blocking mode */ 111 | void cssl_settimeout(cssl_t *serial, int timeout); 112 | 113 | /* reads a char in blocking mode */ 114 | int cssl_getchar(cssl_t *serial); 115 | 116 | /* reads a data to a buffer in blocking mode*/ 117 | int cssl_getdata(cssl_t *serial, 118 | uint8_t *buffer, /* buffer for data */ 119 | int size); /* buffer size */ 120 | 121 | 122 | #endif /* __CSSL_H__ */ 123 | -------------------------------------------------------------------------------- /libcssl.spec: -------------------------------------------------------------------------------- 1 | Summary: Columbo Simple Serial Library 2 | Name: libcssl 3 | Version: 0.9.4 4 | Release: 1 5 | License: LGPL 6 | Group: System Environment/Libraries 7 | URL: http://cssl.sf.net 8 | Source0: %{name}-%{version}.tar.gz 9 | BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot 10 | 11 | %description 12 | Columbo Simple Serial Library is an easy to use, event driven serial port communication library for Linux. 13 | 14 | %prep 15 | %setup -q 16 | 17 | %build 18 | make PREFIX=%{_prefix} 19 | 20 | %install 21 | make PREFIX=$RPM_BUILD_ROOT%{_prefix} install 22 | 23 | %clean 24 | rm -rf $RPM_BUILD_ROOT 25 | 26 | %post -p /sbin/ldconfig 27 | 28 | %postun -p /sbin/ldconfig 29 | 30 | %files 31 | %defattr(-,root,root,-) 32 | %dir %{_prefix}/lib 33 | %dir %{_prefix}/include 34 | %dir %{_prefix}/lib/pkgconfig 35 | %{_prefix}/include/cssl.h 36 | %{_prefix}/lib/libcssl.a 37 | %{_prefix}/lib/libcssl.la 38 | %{_prefix}/lib/libcssl.so.0.0.9 39 | %{_prefix}/lib/pkgconfig/libcssl.pc 40 | %doc COPYING README INSTALL 41 | 42 | 43 | %changelog 44 | * Thu Nov 20 2003 Marcin Siennicki - 45 | - Initial build. 46 | 47 | 48 | -------------------------------------------------------------------------------- /libcssl.spec.in: -------------------------------------------------------------------------------- 1 | Summary: Columbo Simple Serial Library 2 | Name: libcssl 3 | Version: ____CSSL_VERSION____ 4 | Release: 1 5 | License: LGPL 6 | Group: System Environment/Libraries 7 | URL: http://cssl.sf.net 8 | Source0: %{name}-%{version}.tar.gz 9 | BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot 10 | 11 | %description 12 | Columbo Simple Serial Library is an easy to use, event driven serial port communication library for Linux. 13 | 14 | %prep 15 | %setup -q 16 | 17 | %build 18 | make PREFIX=%{_prefix} 19 | 20 | %install 21 | make PREFIX=$RPM_BUILD_ROOT%{_prefix} install 22 | 23 | %clean 24 | rm -rf $RPM_BUILD_ROOT 25 | 26 | %post -p /sbin/ldconfig 27 | 28 | %postun -p /sbin/ldconfig 29 | 30 | %files 31 | %defattr(-,root,root,-) 32 | %dir %{_prefix}/lib 33 | %dir %{_prefix}/include 34 | %dir %{_prefix}/lib/pkgconfig 35 | %{_prefix}/include/cssl.h 36 | %{_prefix}/lib/libcssl.a 37 | %{_prefix}/lib/libcssl.la 38 | %{_prefix}/lib/libcssl.so.0.0.9 39 | %{_prefix}/lib/pkgconfig/libcssl.pc 40 | %doc COPYING README INSTALL 41 | 42 | 43 | %changelog 44 | * Thu Nov 20 2003 Marcin Siennicki - 45 | - Initial build. 46 | 47 | 48 | -------------------------------------------------------------------------------- /test.c: -------------------------------------------------------------------------------- 1 | 2 | /* Example application of Columbo Simple Serial Library 3 | * Copyright 2003 Marcin Siennicki 4 | * see COPYING file for details */ 5 | 6 | #include 7 | #include 8 | 9 | #include "cssl.h" 10 | 11 | 12 | /* if it is time to finish */ 13 | static int finished=0; 14 | 15 | 16 | /* example callback, it gets its id, buffer, and buffer length */ 17 | static void callback(int id, 18 | uint8_t *buf, 19 | int length) 20 | { 21 | int i; 22 | 23 | for(i=0;i