A lot Information

Linux Delete All Files In Directory

admin — Wed, 18 Jan 2012 00:04:04 +0000

This command delete all files in current directory:

1	sudo rm -rf *

sudo rm -rf *

URL’s Content Using PHP cURL

admin — Tue, 17 Jan 2012 17:56:44 +0000

Downloading content at a specific URL is common practice on the internet, especially due to increased usage of web services and APIs offered by Amazon, Alexa, Digg, etc. PHP’s cURL library, which often comes with default shared hosting configurations, allows web developers to complete this task.
The Code:

/* gets the data from a URL */
function get_data($url)
{
  $ch = curl_init();
  $timeout = 5;
  curl_setopt($ch,CURLOPT_URL,$url);
  curl_setopt($ch,CURLOPT_RETURNTRANSFER,1);
  curl_setopt($ch,CURLOPT_CONNECTTIMEOUT,$timeout);
  $data = curl_exec($ch);
  curl_close($ch);
  return $data;
}

/* gets the data from a URL */
function get_data($url)
{
  $ch = curl_init();
  $timeout = 5;
  curl_setopt($ch,CURLOPT_URL,$url);
  curl_setopt($ch,CURLOPT_RETURNTRANSFER,1);
  curl_setopt($ch,CURLOPT_CONNECTTIMEOUT,$timeout);
  $data = curl_exec($ch);
  curl_close($ch);
  return $data;
}

The Usage:

1	$returned_content = get_data('http://davidwalsh.name');

$returned_content = get_data('http://davidwalsh.name');

Alternatively, you can use the file_get_contents function remotely, but many hosts don’t allow this.

Info from: http://davidwalsh.name

PHP File Upload Tutorial

admin — Mon, 16 Jan 2012 23:09:10 +0000

This tutorial will demonstrate how to handle file uploads in PHP. We will create a simple XHTML form with a file field, and a PHP script that handles the form submission by moving the uploaded file to a designated directory. This tutorial assumes you are using PHP 4.4.0 or higher.

XHTML for the File Upload Form

The XHTML code for the file field is simply an input field with the type attribute set to “file”, and the name attribute set to an arbitrary value. The value provided for the name attribute will be used to identify the uploaded file in our PHP script after the form is submitted. In addition, the containing form tag must have the enctype attribute set to “multipart/form-data” in order for it to work correctly. There is also an optional hidden field for the maximum file size, appropriately named MAX_FILE_SIZE. Note that the MAX_FILE_SIZE parameter can be easily circumvented via a cross-site request forgery. Therefore, the code that handles the uploaded file should always perform a separate check of file size, independent of the MAX_FILE_SIZE parameter.

Below is an example form that can be used to accept the file. This form assumes that the script that will handle the upload is named “upload.php”.

<form enctype="multipart/form-data" action="upload.php"
    method="post">
<input type="hidden" name="MAX_FILE_SIZE"
    value="50000" />
Select a File:<br />
<input type="file" size="20" name="thefile" /><br />
<input type="submit" name="Submit" value="Submit" />
</form>



Select a File:

PHP Code for the File Upload Handler

Information about the uploaded file is stored in the $_FILES array. The name of the file field on the page determines the key of the uploaded file in this array, e.g. $_FILES['thefile'].

Our PHP code will check the $_FILES array for the key corresponding to the name of the file field in the form we created above. If the key exists, the file upload handling logic will be performed.

1
2
3

if(array_key_exists('thefile', $_FILES)) {
    // Handle the uploaded file here
}

if(array_key_exists('thefile', $_FILES)) {
	// Handle the uploaded file here
}

The handler script must check a number of conditions in order to validate the submission. It should confirm that a file was actually selected, that the file does not exceed maximum acceptable size, and that the PHP engine itself did not encounter an error while handling the file.

if(array_key_exists('thefile', $_FILES)) {
 
// Validate the uploaded file
if($_FILES['thefile']['size'] === 0
|| empty($_FILES['thefile']['tmp_name'])) {
    echo("No file was selected.
\r\n");
} else if($_FILES['thefile']['size'] > 50000) {
    echo("The file was too large.
\r\n");
} else if($_FILES['thefile']['error'] !== UPLOAD_ERR_OK) {
    // There was a PHP error
    echo("There was an error uploading.
\r\n");
} else {
    // Do the rest of the file handling here
}
 
}

if(array_key_exists('thefile', $_FILES)) {

// Validate the uploaded file
if($_FILES['thefile']['size'] === 0
|| empty($_FILES['thefile']['tmp_name'])) {
    echo("No file was selected.\r\n");
} else if($_FILES['thefile']['size'] > 50000) {
    echo("The file was too large.\r\n");
} else if($_FILES['thefile']['error'] !== UPLOAD_ERR_OK) {
    // There was a PHP error
    echo("There was an error uploading.\r\n");
} else {
	// Do the rest of the file handling here
}

}

Each item in the $_FILES array is itself an array representing various attributes of the uploaded file. If a file was not selected for the corresponding field, the “size” item will be zero, and the “tmp_name” item will be empty.

Assuming a successful upload, the “size” item will contain the actual size of the uploaded file in bytes. The “tmp_name” item will contain the name of the temporary file where the upload was saved. The handler script must move the temporary file to another location, otherwise the PHP engine will delete the file upon completion of the request.

The “error” item will contain a code reflecting the status of the upload. If the upload was successful, it will return the constant UPLOAD_ERR_OK. The list of possible error codes can be found in the PHP Manual.

Lastly, our example script must move the uploaded file to another directory. The code below will create a destination directory named “uploads” if it does not exist, and call the PHP function move_uploaded_file() to move the file to that directory.

if(array_key_exists('thefile', $_FILES)) {
 
// Validate the uploaded file
if($_FILES['thefile']['size'] === 0
|| empty($_FILES['thefile']['tmp_name'])) {
    echo("No file was selected.
\r\n");
} else if($_FILES['thefile']['size'] > 50000) {
    echo("The file was too large.
\r\n");
} else if($_FILES['thefile']['error'] !== UPLOAD_ERR_OK) {
    // There was a PHP error
    echo("There was an error uploading.
\r\n");
} else {
 
// Create uploads directory if necessary
if(!file_exists('uploads')) mkdir('uploads');
 
// Move the file
if(move_uploaded_file($_FILES['thefile']['tmp_name'],
'uploads/' . $_FILES['thefile']['name'])) {
    echo("File uploaded successfully!
\r\n");
} else {
    echo("There was an error moving the file.
\r\n");
}
 
}
 
}

if(array_key_exists('thefile', $_FILES)) {

// Validate the uploaded file
if($_FILES['thefile']['size'] === 0
|| empty($_FILES['thefile']['tmp_name'])) {
    echo("No file was selected.\r\n");
} else if($_FILES['thefile']['size'] > 50000) {
    echo("The file was too large.\r\n");
} else if($_FILES['thefile']['error'] !== UPLOAD_ERR_OK) {
    // There was a PHP error
    echo("There was an error uploading.\r\n");
} else {

// Create uploads directory if necessary
if(!file_exists('uploads')) mkdir('uploads');

// Move the file
if(move_uploaded_file($_FILES['thefile']['tmp_name'],
'uploads/' . $_FILES['thefile']['name'])) {
    echo("File uploaded successfully!\r\n");
} else {
    echo("There was an error moving the file.\r\n");
}

}

}

Make sure to use the move_uploaded_file() function rather than one of the general purpose file handling functions, as this function will perform a security check to confirm that the specified file is in fact a valid uploaded file.

Hopefully this tutorial has given you a good idea of how file uploads are handled in PHP. Please note that this simple example code is provided for learning purposes only. When allowing uploads on a public website, you would probably want to add some form of authorization, and filter the types of files being uploaded.

Info from: http://www.dbscripts.net

Website Thumbnail Generator PHP Script

admin — Mon, 16 Jan 2012 22:58:57 +0000

Requirements:
Windows hosting
PHP GD library (installed on most hostings)
Permissions to execute third-party applications (i.e. exe files)
Permissions to execute Internet Explorer

How it works:
Website Thumbnail Generator checks if it already has website image in the cache, and shows it in the browser.
If no cached image then IECapt would be run from the script.
IECapt would run Internet Explorer, grab full sized website screenshot from it, and save image into the folder you specified in script settings.
Then Website Thumbnail Generator would resize image, and show it in the browser.

Download script here: webthumb


###############################################################
# Website Thumbnail Image Generator 1.1
###############################################################
# Visit http://www.zubrag.com/scripts/ for updates
###############################################################
#
# REQUIREMENTS:
# PHP 4.0.6 and GD 2.0.1 or later
# May not work with GIFs if GD2 library installed on your server
# does not support GIF functions in full
#
# Parameters that can be passed via url (if not passed will be used values which are set below):
# url - url of the target website
# x - max width
# y - max height
# q - quality (applicable only to JPG, 1 to 100, 100 - best)
#
# Sample usage:
# 1. webthumb.php?url=http://www.microsoft.com
# 2. Set maximum thumbnail size to 150
#    webthumb.php?url=http://www.thumbnails.com&x=150&y=150
###############################################################
 
// Folder to save all thumbnails.
// Must end with slash!!!
$thumbnails_folder = 'Z:/home/localhost/www/thumb/cache/';
 
// thumbnails expiration time in minutes
$cache_expire_time = 60;
 
// quality (for jpeg only)
$image_quality = 100;
 
// resulting image type (1 = GIF, 2 = JPG, 3 = PNG)
$image_type = 3;
 
// maximum thumb side size
$max_x = 100;
$max_y = 100;
 
// If not equal 0 then cut original image size before resizing (in pixels).
// Long page will have bad thumbnail, its better to cut page length first.
$cut_x = 0;
$cut_y = 1024;
 
###############################################################################
# END OF SETTINGS. DO NOT EDIT BELOW
###############################################################################
 
if (isset($_REQUEST['url'])) {
  $website_url = $_REQUEST['url'];
}
else {
  die("Site URL must be specified.");
}
 
if ($image_type == 1) $output_format = 'gif';
if ($image_type == 2) $output_format = 'jpg';
if ($image_type == 3) $output_format = 'png';
 
$website_url_md5 = md5($website_url);
 
$cached_filename = $thumbnails_folder . $website_url_md5 . '.' . $output_format;
 
// See if we have cached website screenshot image (to minimize server load)
if (!file_exists($cached_filename)
|| filemtime ($cached_filename) + $cache_expire_time * 60 < time() ) {
 
  // Get website image and save it on the server.
  @exec('IECapt.exe ' . escapeshellarg($website_url) . ' ' . escapeshellarg($cached_filename));
 
} // if (!file_exists
 
if (!file_exists($cached_filename)) {
  die("Thumbnail Generation Error. Thumbnail not created.");
}
 
// create class instance
include("image.class.php");
$img = new Zubrag_image;
 
// get parameters
$img->image_type   = $image_type;
$img->quality      = isset($_REQUEST['q']) ? intval($_REQUEST['q']) : $image_quality;
$img->max_x        = isset($_REQUEST['x']) ? intval($_REQUEST['x']) : $max_x;
$img->max_y        = isset($_REQUEST['y']) ? intval($_REQUEST['y']) : $max_y;
$img->save_to_file = false;
$img->cut_x        = $cut_x;
$img->cut_y        = $cut_y;
 
// generate thumbnail and show it
$img->GenerateThumbFile($cached_filename, '');
 
?>

image_type   = $image_type;
$img->quality      = isset($_REQUEST['q']) ? intval($_REQUEST['q']) : $image_quality;
$img->max_x        = isset($_REQUEST['x']) ? intval($_REQUEST['x']) : $max_x;
$img->max_y        = isset($_REQUEST['y']) ? intval($_REQUEST['y']) : $max_y;
$img->save_to_file = false;
$img->cut_x        = $cut_x;
$img->cut_y        = $cut_y;

// generate thumbnail and show it
$img->GenerateThumbFile($cached_filename, '');

?>

Info from: http://www.zubrag.com

UNIX File Permissions Tutorial

admin — Mon, 16 Jan 2012 22:48:36 +0000

Understanding file permissions on Unix: a brief tutorial
(For files on AFS fileservers, see below)

Every user on a Unix system has a unique username, and is a member of at least one group (the primary group for that user). This group information is held in the password file (/etc/passwd). A user can also be a member of one or more other groups. The auxiliary group information is held in the file /etc/group. Only the administrator can create new groups or add/delete group members (one of the shortcomings of the system).

Every directory and file on the system has an owner, and also an associated group. It also has a set of permission flags which specify separate read, write and execute permissions for the ‘user’ (owner), ‘group’, and ‘other’ (everyone else with an account on the computer) The ‘ls’ command shows the permissions and group associated with files when used with the -l option. On some systems (e.g. Coos), the ‘-g’ option is also needed to see the group information.

An example of the output produced by ‘ls -l’ is shown below.
drwx—— 2 richard staff 2048 Jan 2 1997 private
drwxrws— 2 richard staff 2048 Jan 2 1997 admin
-rw-rw—- 2 richard staff 12040 Aug 20 1996 admin/userinfo
drwxr-xr-x 3 richard user 2048 May 13 09:27 public
Understanding how to read this output is useful to all unix users, but especially people using group access permissions.

Field 1: a set of ten permission flags.
Field 2: link count (don’t worry about this)
Field 3: owner of the file
Field 4: associated group for the file
Field 5: size in bytes
Field 6-8: date of last modification (format varies, but always 3 fields)
Field 9: name of file (possibly with path, depending on how ls was called)

The permission flags are read as follows (left to right) position Meaning
1 directory flag, ‘d’ if a directory, ‘-’ if a normal file, something else occasionally may appear here for special devices.
2,3,4 read, write, execute permission for User (Owner) of file
5,6,7 read, write, execute permission for Group
8,9,10 read, write, execute permission for Other
value Meaning
- in any position means that flag is not set
r file is readable by owner, group or other
w file is writeable. On a directory, write access means you can add or delete files
x file is executable (only for programs and shell scripts – not useful for data files). Execute permission on a directory means you can list the files in that directory
s in the place where ‘x’ would normally go is called the set-UID or set-groupID flag.

On an executable program with set-UID or set-groupID, that program runs with the effective permissions of its owner or group.
For a directory, the set-groupID flag means that all files created inside that directory will inherit the group of the directory. Without this flag, a file takes on the primary group of the user creating the file. This property is important to people trying to maintain a directory as group accessible. The subdirectories also inherit the set-groupID property.

The default file permissions (umask):
Each user has a default set of permissions which apply to all files created by that user, unless the software explicitly sets something else. This is often called the ‘umask’, after the command used to change it. It is either inherited from the login process, or set in the .cshrc or .login file which configures an individual account, or it can be run manually.

Typically the default configuration is equivalent to typing ‘umask 22′ which produces permissions of:
-rw-r–r– for regular files, or
drwxr-xr-x for directories.
In other words, user has full access, everyone else (group and other) has read access to files, lookup access to directories.

When working with group-access files and directories, it is common to use ‘umask 2′ which produces permissions of:
-rw-rw-r– for regular files, or
drwxrwxr-x for directories.
For private work, use ‘umask 77′ which produces permissions:
-rw——- for regular files, or
drwx—— for directories.
The logic behind the number given to umask is not intuitive.

The command to change the permission flags is “chmod”. Only the owner of a file can change its permissions.

The command to change the group of a file is “chgrp”. Only the owner of a file can change its group, and can only change it to a group of which he is a member.

See the online manual pages for details of these commands on any particular system (e.g. “man chmod”).

Examples of typical useage are given below:

1	chmod g+w myfile

chmod g+w myfile

give group write permission to “myfile”, leaving all other permission flags alone

1	chmod g-rw myfile

 chmod g-rw myfile

remove read and write access to “myfile”, leaving all other permission flags alone

1	chmod g+rwxs mydir

chmod g+rwxs mydir

give full group read/write access to directory “mydir”, also setting the set-groupID flag so that directories created inside it inherit the group

1	chmod u=rw,go= privatefile

chmod u=rw,go= privatefile

explicitly give user read/write access, and revoke all group and other access, to file ‘privatefile’

1	chmod -R g+rw

 chmod -R g+rw

give group read write access to this directory, and everything inside of it (-R = recursive)

1	chgrp -R medi

 chgrp -R medi

change the ownership of this directory to group ‘medi’ and everything inside of it (-R = recursive). The person issuing this command must own all the files or it will fail.

WARNINGS:

Putting ‘umask 2′ into a startup file (.login or .cshrc) will make these settings apply to everything you do unless manually changed. This can lead to giving group access to files such as saved email in your home directory, which is generally not desireable.

Making a file group read/write without checking what its group is can lead to accidentally giving access to almost everyone on the system. Normally all users are members of some default group such as “users”, as well as being members of specific project-oriented groups. Don’t give group access to “users” when you intended some other group.

Remember that to read a file, you need execute access to the directory it is in AND read access to the file itself. To write a file, your need execute access to the directory AND write access to the file. To create new files or delete files, you need write access to the directory. You also need execute access to all parent directories back to the root. Group access will break if a parent directory is made completely private.
AFS Access Control Lists (ACLs)
Files on the central AFS fileservers all have the traditional Unix permissions as explained above, but they are also controlled by Access Control Lists (ACL) which take precedence. They provide access levels more flexible than the user/group/other attribute bits, but they work on the level of complete directories, not files. The command to set and list ACLs is fs.
“fs” is a big ugly command that does lots of things related to AFS filesystems depending on the arguments you call it with.

For details see the man pages for: fs_setacl, fs_listacl, fs_cleanacl, fs_copyacl

For brief help, do (e.g.) “fs help setacl”

The default is to give the same permissions to a new directory as are on the parent directory. In practice, this is usually to give complete rights to the owner of the directory, and lookup rights to any other user (equivalent to execute attribute on a directory).

To render a directory private, the simplest command is:

1	fs setacl -d DIRNAME -clear -a MYNAME all

fs setacl -d DIRNAME -clear -a MYNAME all

- replace DIRNAME with the appropriate directory name (or “.” for the current directory, and MYNAME with your login name.

Check it with:

fs listacl DIRNAME

It should reply with:
Access list for DIRNAME is
Normal rights:
USERNAME rlidwka

(see man fs_setacl for a description of the meaning of the flags “rlidwka”)

To explicitly give public read/lookup access, use:

fs setacl -d DIRNAME -a system:anyuser read

This can be abbreviated to

fs sa DIRNAME system:anyuser read

If “fs” is not found, or the man pages are not found, your paths are not set up correctly. I recommend you run /usr/local/bin/mknewdotfiles to correct that.

Info from: http://www.dartmouth.edu

MySQL Query Example Script

admin — Mon, 16 Jan 2012 16:52:57 +0000


// Connection
mysql_connect("localhost", "name", "pass") or die(mysql_error());
mysql_select_db("test") or die(mysql_error());
 
$result = mysql_query("SELECT name,age FROM users")
or die(mysql_error());  
 
$row = mysql_fetch_array( $result );
 
echo "Name: ".$row['name'];
echo " Age: ".$row['age'];
 
?>

MySQL Insert Example Script

admin — Mon, 16 Jan 2012 16:16:09 +0000


// Connect
mysql_connect("localhost", "name", "pass") or die(mysql_error());
mysql_select_db("dbname") or die(mysql_error());
 
// Insert into "test"
mysql_query("INSERT INTO test (name, nickname) VALUES ('Arnold', 'Shwarc')") or die(mysql_error());
 
echo "Done!";
 
?>

Create Table Example MySQL

admin — Mon, 16 Jan 2012 16:10:47 +0000


 
mysql_connect("localhost", "name", "pass") or die(mysql_error());
mysql_select_db("dbname") or die(mysql_error());
 
mysql_query("CREATE TABLE example(
id INT NOT NULL AUTO_INCREMENT,
PRIMARY KEY(id),
 name VARCHAR(30),
 age INT)")
 or die(mysql_error());
 
?>

MySQL Connect Example Script

admin — Mon, 16 Jan 2012 16:06:24 +0000


mysql_connect("localhost", "name", "password") or die(mysql_error());
echo "Connected Done
";
?>

";
?>

Hello World PHP Script

admin — Mon, 16 Jan 2012 13:41:08 +0000

1
2
3


echo "Hello World!";
?>