basic coder

#include <gst/gst.h>
 
static void
add_pad (GstElement *element , GstPad *pad , gpointer data){
 
	gchar *name;
	GstElement *sink = (GstElement*)data;
 
	name = gst_pad_get_name(pad);
	gst_element_link_pads(element , name , sink , "sink");
	g_free(name);
}
 
static gboolean
bus_watch(GstBus *bus , GstMessage *msg , gpointer data)
{
    GMainLoop *loop = (GMainLoop *) data;
    if(GST_MESSAGE_TYPE(msg) == GST_MESSAGE_EOS){
        g_main_loop_quit(loop);
    }
    return TRUE;
}
 
void
play_file(const char *filename){
 
	GMainLoop *loop;
	GstElement *pipeline;
	GstBus *bus;
	GstElement *source , *parser , *sink;
 
	loop = g_main_loop_new(NULL , TRUE);
 
	pipeline = gst_pipeline_new("audio-player");
 
	source = gst_element_factory_make("filesrc" , "source");
	parser = gst_element_factory_make("wavparse" , "parser");
	sink = gst_element_factory_make("alsasink" , "output");
 
	g_object_set(G_OBJECT(source) , "location"
			, filename , NULL);
 
	bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline));
	gst_bus_add_watch(bus , bus_watch , loop);
	g_object_unref(bus);
 
	gst_bin_add_many(GST_BIN(pipeline)
			, source , parser , sink , NULL);
 
	g_signal_connect(parser
			, "pad-added" , G_CALLBACK(add_pad) , sink);
 
	if(! gst_element_link(source , parser)){
		g_warning("linke source to parser failed");
	}
 
	gst_element_set_state(pipeline , GST_STATE_PLAYING);
	printf("Start playing...\n");
	g_main_loop_run(loop);
	printf("Playing stopped!!!\n");
	gst_element_set_state(pipeline , GST_STATE_NULL);
	g_object_unref(pipeline);
}
 
int
main(int argc , char *argv[]){
 
	gst_init(&argc , &argv);
 
	play_file(argv[1]);
 
	return 0;
}

$gcc -o gst gst.c `pkg-config --cflags --libs gstreamer-0.10`

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
 
#define STUN_SERVER_IP "132.177.123.13"
#define STUN_SERVER_PORT 3478
 
int socketfd;
 
struct stun_header{
	unsigned short type;
	unsigned short length;
	unsigned int transId1;
	unsigned int transId2;
	unsigned int transId3;
	unsigned int transId4;
};
 
struct mapped_address{
	unsigned padding : 8;
	unsigned family : 8;
	unsigned short port;
	unsigned int address;
};
 
int 
init_socket(){
	socketfd = socket(AF_INET , SOCK_DGRAM , 0);
}
 
int 
stun_rand(){
	srand(time(NULL));
	return rand();
}
 
struct stun_header* 
build_stun_header(unsigned short type){
 
	struct stun_header *header ;
 
	header = (struct stun_header*)malloc(sizeof(struct stun_header));
	header->type = htons(type);
	header->length = 0;
	header->transId1 = stun_rand();
	header->transId2 = stun_rand();
	header->transId3 = stun_rand();
	header->transId4 = stun_rand();
 
	return header;
}
 
int 
udp_send(void *data , int len
		, const char *ip , int port){
 
	struct sockaddr_in addr;
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = inet_addr(ip);
	addr.sin_port = htons(port);
 
	return sendto(socketfd , data , len , 0
			, (struct sockaddr*)&addr , sizeof(struct sockaddr));
 
}
 
int 
main(int argc , char *argv[]){
 
	init_socket();
	struct stun_header recv_header;
	struct sockaddr_in addr;
	size_t length;
 
	struct stun_header* header
		= build_stun_header(0x0001);
 
	udp_send(header , sizeof(struct stun_header)
			, STUN_SERVER_IP , STUN_SERVER_PORT);
 
	length = sizeof(struct sockaddr);
	recvfrom(socketfd , (void*)&recv_header , sizeof(recv_header) , 0
			, (struct sockaddr*)&addr , &length);
 
	return 0;
}

 #include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
char* base64_encode(const char *src);
 
int main(int argc , char *argv[])
{
	const char in[] = "levin";
	char *res = base64_encode(in);
	printf("%s\n" , res);
	free(res);
	return 0;
}
char* base64_encode(const char *src){
 
	char* dest;
	char in[4];
	long buf = 0 , tmp = 0;
	int i = 0 , j = 0 , count = 0;
	char table[] = {
	    'A' , 'B' , 'C' , 'D' , 'E' , 'F' , 'G'
	  , 'H' , 'I' , 'J' , 'K' , 'L' , 'M' , 'N'
	  , 'O' , 'P' , 'Q' , 'R' , 'S' , 'T' , 'U'
	  , 'V' , 'W' , 'X' , 'Y' , 'Z' , 'a' , 'b'
	  , 'c' , 'd' , 'e' , 'f' , 'g' , 'h' , 'i'
	  , 'j' , 'k' , 'l' , 'm' , 'n' , 'o' , 'p'
	  , 'q' , 'r' , 's' , 't' , 'u' , 'v' , 'w'
	  , 'x' , 'y' , 'z' , '0' , '1' , '2' , '3'
	  , '4' , '5' , '6' , '7' , '8' , '9' , '+'
	  , '/' , '='
	};
 
	count = strlen(src) / 3 + (strlen(src) % 3 == 0 ? 0 : 1);
	dest = (char*)malloc(count * 4 + 1);
 
	for( ; j < count ; j++){
 
		bzero(in , sizeof(in));
		strncpy(in , src + j * 3 , 3 );
 
		buf = 0 , buf = 0 , i = 0; 
 
		for(; i < strlen(in) ; i++){
			tmp = (long)in[i];
			tmp <<= (16 - i * 8);
			buf |= tmp;
		}
 
		for(i = 0; i < 4 ; i ++){
			if(strlen(in) + 1 > i){
				tmp = buf >> (18 - i * 6);
				tmp &= 0x3F;
				dest[j * 4 + i] = table[tmp];
			}else{
				dest[j * 4 + i] = '=';
			}
		}
	}
	return dest;
}

EVP_EncodeBlock(out , (unsigned char*)in , strlen(in));

unsigned char* strtohex(const char* in , int* len) 
{
	unsigned char* out = (unsigned char*)malloc(strlen(in)/2 );
	int i = 0 , j = 0 , k = 0 ,length = 0;
 	char tmp[2] = { 0 };
	memset(out , 0 , strlen(in) / 2);
	while(i < (int)strlen(in))
	{
		tmp[k++] = in[i++];
                tmp[k] = '\0';
		if(k == 2)
		{
			out[j++] = (unsigned char)strtol(tmp , (char**)NULL , 16);
			k = 0;
			length ++;
		}
	}
	if(len != NULL )
		*len = length;
	return out;
}

#include <unistd.h>
 
ssize_t readlink(const char *restrict path , char *restrict buf , size_t bufsize);

#include <unistd.h>
#include <stdio.h>
 
int main(int argc , char* argv[])
{
	char buf[1024] = { 0 };
	int n;
 
	n = readlink("/bin/mail" , buf , sizeof(buf));
	if( n > 0 && n < sizeof(buf))
	{
		printf("%s\n" , buf);
	}
}

#include <unistd.h>
#include <stdio.h>
 
int main(int argc , char* argv[])
{
	char buf[1024] = { 0 };
	int n;
 
	n = readlink("/proc/self/exe" , buf , sizeof(buf));
	if( n > 0 && n < sizeof(buf))
	{
		printf("%s\n" , buf);
	}
}

ouclwp@darkstar:~/socket$ ./read 
/home/ouclwp/socket/read

void test()
{
       char* name = new char[10];
}

char* test()
{
       char name[] = "hello world";
       return name;
}

char* test()
{
       char* name = new char[10];
       ........
       return name;
}

void test(char* name)
{
        strcpy(name , "hello world!");
}

char name[20] = { 0 };//我习惯这样初始化字符数组
test(name);

class test
{
    public:
       test();
       void hello();
       void initialize();
       static test* pthis;
       static void testfunc(GtkWidget* widget , gpointer data);
};
void test::initialize()
{
    test* pthis = this;//静态成员函数是不能在类中赋值的，这里相当于定义。
    ...............
    g_signal_connect(someobj , "clicked" , G_CALLBACK(testfunc) , pthis);
}
void test::testfunc(GtkWidget* widget , gpointer data);
{
    test* pthis = static_cast<test*>(data);
    pthis->hello();
}