Free printf software for linux

passwd_info is a simple program that can query the /etc/passwd file for current user or specified user.

USAGE: passwd_info [username]

Sample:

#include < unistd.h >
#include < stdlib.h >
#include < stdio.h >
#include < sys/types.h >
#include < pwd.h >
#include < string.h >

struct passwd *pw;

void print_usage(void);

int main( int argc, char *argv[] )
{
if ( argc > 2 ) {
print_usage();
exit(1);
}

char *name;
uid_t uid;
gid_t gid;
char *gecos;
char *dir;
char *shell;

char *user_arg;

if ( argv[1] != NULL ) {
user_arg=(char *)malloc(strlen(argv[1]));
strcpy( user_arg, argv[1] );
if ( (pw = getpwnam(user_arg) ) == NULL ) {
fprintf( stderr, "Error: user %s does not existn", user_arg );
exit(1);
}
uid = pw->pw_uid;
free(user_arg);
}
else /* get for current user */
{
uid = getuid();
pw = getpwuid(uid);
}

name = pw->pw_name;
gid = pw->pw_gid;
gecos = pw->pw_gecos;
dir = pw->pw_dir;
shell = pw->pw_shell;

printf( "/etc/passwd file information for %sn", name );
printf( "Username = %stUID = %dtGID = %dn", name, (int)uid, (int)gid );
printf( "GECOS = %snHome = %stShell = %sn", gecos, dir, shell );

exit(0);
}

void print_usage( void )
{
fprintf( stderr, "USAGE: passwd_info [username]n" );
}

Persistent::Sybase is a persistent class implemented using a Sybase database.

SYNOPSIS

use Persistent::Sybase;
use English; # import readable variable names like $EVAL_ERROR

eval { ### in case an exception is thrown ###

### allocate a persistent object ###
my $emp = new Persistent::Sybase($data_source, $username, $password, $table);

### define attributes of the object ###
$emp->add_attribute(empno, ID, Number, undef, 4);
$emp->add_attribute(ename, Persistent, VarChar, undef, 10);
$emp->add_attribute(job, Persistent, VarChar, undef, 9);
$emp->add_attribute(mgr, Persistent, Number, undef, 4);
$emp->add_attribute(hiredate, Persistent, DateTime, undef);
$emp->add_attribute(sal, Persistent, Number, undef, 7, 2);
$emp->add_attribute(comm, Persistent, Number, undef, 7, 2);
$emp->add_attribute(deptno, Persistent, Number, undef, 2);

### query the datastore for some objects ###
$emp->restore_where(qq{
sal > 1000 and
job = CLERK and
ename LIKE M%
}, "sal, ename");
while ($emp->restore_next()) {
printf "ename = %s, emp# = %s, sal = %s, hiredate = %sn",
$emp->ename, $emp->empno, $emp->sal, $emp->hiredate;
}
};

if ($EVAL_ERROR) { ### catch those exceptions! ###
print "An error occurred: $EVAL_ERRORn";
}

ABSTRACT

This is a Persistent class that uses a Sybase database table to store and retrieve objects. This class can be instantiated directly or subclassed. The methods described below are unique to this class, and all other methods that are provided by this class are documented in the Persistent documentation. The Persistent documentation has a very thorough introduction to using the Persistent framework of classes.

SimpleIni is a cross-platform library that provides a simple API to read and write INI-style configuration files. It supports data files in ASCII, MBCS and Unicode.
It is designed explicitly to be portable to any platform and has been tested on Windows and Linux. Released as open-source and free using the MIT licence.
Examples:
These snippets are included with the distribution in the file snippets.cpp.
LOADING DATA
load from a data file
CSimpleIniA ini(a_bIsUtf8, a_bUseMultiKey, a_bUseMultiLine);
SI_Error rc = ini.LoadFile(a_pszFile);
if (rc < 0) return false;
load from a string
std::string strData;
rc = ini.Load(strData.c_str(), strData.size());
if (rc < 0) return false;
GETTING SECTIONS AND KEYS
get all sections
CSimpleIniA::TNamesDepend sections;
ini.GetAllSections(sections);
get all keys in a section
CSimpleIniA::TNamesDepend keys;
ini.GetAllKeys("section-name", keys);
GETTING VALUES
get the value of a key
const char * pszValue = ini.GetValue("section-name",
"key-name", NULL /*default*/);
get the value of a key which may have multiple values. If bHasMultipleValues is true, then just one value has been returned
bool bHasMultipleValues;
pszValue = ini.GetValue("section-name", "key-name",
NULL /*default*/, &bHasMultipleValues);
get all values of a key with multiple values
CSimpleIniA::TNamesDepend values;
ini.GetAllValues("section-name", "key-name", values);
sort the values into the original load order
values.sort(CSimpleIniA::Entry::LoadOrder());
output all of the items
CSimpleIniA::TNamesDepend::const_iterator i;
for (i = values.begin(); i != values.end(); ++i) {
printf("key-name = %sn", i->pItem);
}
MODIFYING DATA
adding a new section
rc = ini.SetValue("new-section", NULL, NULL);
if (rc < 0) return false;
printf("section: %sn", rc == SI_INSERTED ?
"inserted" : "updated");
adding a new key ("new-section" will be added automatically if it doesnt already exist)
rc = ini.SetValue("new-section", "new-key", "value");
if (rc < 0) return false;
printf("key: %sn", rc == SI_INSERTED ?
"inserted" : "updated");
changing the value of a key
rc = ini.SetValue("section", "key", "updated-value");
if (rc < 0) return false;
printf("key: %sn", rc == SI_INSERTED ?
"inserted" : "updated");
DELETING DATA
deleting a key from a section. Optionally the entire section may be deleted if it is now empty.
ini.Delete("section-name", "key-name",
true /*delete the section if empty*/);
deleting an entire section and all keys in it
ini.Delete("section-name", NULL);
SAVING DATA
save the data to a string
rc = ini.Save(strData);
if (rc < 0) return false;
save the data back to the file
rc = ini.SaveFile(a_pszFile);
if (rc < 0) return false;
Enhancements:
- Fixed a bug causing multi-line values and comments to get corrupted. This affects only files with CR LF line endings (Windows) and wchar_t/ICU interface (Unicode).

MP3::Find is a Perl module to search and sort MP3 files based on their ID3 tags.

SYNOPSIS

# select with backend you want
use MP3::Find qw(Filesystem);

print "$_n" foreach find_mp3s(
dir => /home/peter/cds,
query => {
artist => ilyaimy,
title => deep in the am,
},
ignore_case => 1,
exact_match => 1,
sort => [qw(year album tracknum)],
printf => %2n. %a - %t (%b: %y),
);

This module allows you to search for MP3 files by their ID3 tags. You can ask for the results to be sorted by one or more of those tags, and return either the list of filenames (the deault), a printf-style formatted string for each file using its ID3 tags, or the actual Perl data structure representing the results.

There are currently two backends to this module: MP3::Find::Filesystem and MP3::Find::DB. You choose which one you want by passing its name as the argument to you use statement; MP3::Find will look for a MP3::Find::$BACKEND module. If no backend name is given, it will default to using MP3::Find::Filesystem.
Note: Im still working out some kinks in the DB backend, so it is currently not as stable as the Filesystem backend.

Note the second: This whole project is still in the alpha stage, so I can make no guarentees that there wont be significant interface changes in the next few versions or so. Also, comments about what about the API rocks (or sucks!) are appreciated.

HTTP::MobileAgent::Vodafone is a Perl module with a Vodafone implementation.

SYNOPSIS

use HTTP::MobileAgent;

local $ENV{HTTP_USER_AGENT} = "J-PHONE/2.0/J-DN02";
my $agent = HTTP::MobileAgent->new;

printf "Name: %sn", $agent->name; # "J-PHONE"
printf "Version: %sn", $agent->version; # 2.0
printf "Model: %sn", $agent->model; # "J-DN02"
print "Packet is compliant.n" if $agent->packet_compliant; # false

# only availabe in Java compliant
# e.g.) "J-PHONE/4.0/J-SH51/SNXXXXXXXXX SH/0001a Profile/MIDP-1.0 Configuration/CLDC-1.0 Ext-Profile/JSCL-1.1.0"
printf "Serial: %sn", $agent->serial_number; # XXXXXXXXXX
printf "Vendor: %sn", $agent->vendor; # SH
printf "Vender Version: %sn", $agent->vendor_version; # "0001a"

my $info = $self->java_info; # hash reference
print map { "$_: $info->{$_}n" } keys %$info;

PScan scans C source files for problematic uses of printf style functions, such as "sprintf(buffer, variable);" instead of "sprintf(buffer, "", variable);". These sort of problems have been the source of many security holes. PSCan looks for them, and nothing else. It does not make your program safe, but it can help to make it safer.

See the Format bugs post to BUGTRAQ for a good explanation of the security problems associated with sprintf(buffer, variable);. These security issues also currently involve being able to bypass stack protection mechanisms like StackGuard. I have submitted a paper to BUGTRAQ describing the issue.

All of these security problems can also occur with any printf-style function. It is simple to fall into the trap of misusing printf and friends, thus, the need for PScan.

What PScan cant do:

Scan for traditional buffer over-flows.
You should use a bounds-checking compiler for that.

Scan for any other mis-use of function parameters.

The functionality given by PScan is limited. Yet it may be useful. Im not going to claim its the be-all and end-all of security scanners, but it does one thing, and it does it simply, and reasonable well.

Analyzing and correcting the security breaches is up to the programmer.

Cspot is a semantic annotator designed only for the C programming language. It is quite similar to cscope, but some more functionality.

Cspot project can be used to find the declarations, definitions, and usages of functions, variables, macros, typedefs, and structs.

It can also find visible identifiers at some position in the source, functions called by a function, global variables used by a function, usages of local variable declarations, unused global variables, unused function definitions, and more. Because it uses sparse, cspot knows more about semantics than cscope.

cspot usage ( cspot -h )
cspot -db spot.db -regexp reg ;; prints all identifiers of project matching reg (extended regexp)
cspot -db spot.db -fc printf ;; prints all declarations of function printf
cspot -db spot.db -fu printf ;; prints all usages of function printf
cspot -db spot.db -vu stdout ;; prints all usages of variable stdout
cspot -db spot.db -sc my_sruct ;; prints places of forward declaration of struct my_struct
cspot -db spot.db -sf my_sruct ;; prints places of definition of struct my_struct
cspot -db spot.db -su my_sruct ;; prints places of usage of struct my_struct
cspot -db spot.db -si my_sruct ;; prints places of definition and variables in struct my_struct
etc.

cspot -va source.c 254 21 ;; prints all visible identifiers at source.c line 254 pos 21
cspot -vla source.c 254 21 ;; prints all visible identifiers (declared in file source.c) at source.c line 254 pos 21

commands for visible functions, macros, variable, called functions by function, global variables used by function ...

cspot -db spot.db -fu printf
printfs all usages of function printf in project (usage = call, assigning to variable)

printf at `base/cmd/commands.h 249:7
printf at `base/cmd/commands.h 327:8
printf at `base/cmd/commands.h 337:8
printf at `base/cmd.c 313:3
printf at `base/cmd.c 318:7
printf at `base/cmd.c 319:36
printf at `base/cmd.c 321:36
printf at `base/cmd.c 322:36
printf at `base/cmd.c 323:36