Der Code-Schnippsel-Thread

#define _GNU_SOURCE
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <unistd.h>
#include <arpa/inet.h>


size_t n;


void sendpx(int fd, int x, int y, const char *color)
{
	char *str;
	n = asprintf(&str, "PX %3d %3d %s\n", x, y, color);
	write(fd, str, n);
	free(str);
}


void sendblock(int fd, int x, int y, int xlen, int ylen, const char *color)
{
	for (int i = x; i < xlen + x; i++) {
		for (int j = y; j < ylen + y; j++) {
			sendpx(fd, i, j, color);
		}
	}
}


int main(int argc, char *argv[])
{
	if (argc != 3) {
		fprintf(stderr, "Usage: %s <IP> <PORT>\n", argv[0]);
		exit(1);
	}


	int sockfd;
	if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
		fprintf(stderr, "Failed to create socket: %s\n", strerror(errno));
		exit(1);
	}


	int portno = atoi(argv[2]);


	struct in_addr *server_ina = malloc(sizeof(struct in_addr));
	if (inet_pton(AF_INET, argv[1], server_ina) != 1) {
		fprintf(stderr, "Could not parse address %s\n", argv[1]);
		exit(1);
	}


	struct sockaddr_in *server_sin = calloc(1, sizeof(struct sockaddr_in));
	server_sin->sin_family = AF_INET;
	server_sin->sin_port = htons(portno);
	server_sin->sin_addr = *server_ina;


	if (connect(sockfd, server_sin, sizeof(*server_sin)) != 0) {
		fprintf(stderr, "Could not connect: %s\n", strerror(errno));
		exit(1);
	}


	while (1) {
		sendblock(sockfd, 0, 0, 333, 35, "E40303");
		sendblock(sockfd, 0, 36, 333, 35, "FF8C00");
		sendblock(sockfd, 0, 71, 333, 35, "FFED00");
		sendblock(sockfd, 0, 106, 333, 35, "008026");
		sendblock(sockfd, 0, 141, 333, 35, "004DFF");
		sendblock(sockfd, 0, 176, 333, 35, "750787");
	}


	close(sockfd);


	return 0;
}

#!/usr/bin/python
# -*- coding: utf-8 -*-


from sense_hat import SenseHat
import time, datetime


hat = SenseHat()


year_color = (0, 255, 0)
month_color = (0, 0, 255)
day_color = (255, 0, 0)
hour_color = (0, 255, 0)
minute_color = (0, 0, 255)
second_color = (255, 0, 0)
hundrefths_color = (127, 127, 0)
off = (0, 0, 0)


hat.clear()


def display_binary(value, row, color):
        binary_str = "{0:8b}".format(value)
        for x in range(0, 8):
                if binary_str[x] == '1':
                        hat.set_pixel(x, row, color)
                else:
                        hat.set_pixel(x, row, off)


while True:
        t = datetime.datetime.now()
        display_binary(t.year % 100, 0, year_color)
        display_binary(t.month, 1, month_color)
        display_binary(t.day, 2, day_color)
        display_binary(t.hour, 3, hour_color)
        display_binary(t.minute, 4, minute_color)
        display_binary(t.second, 5, second_color)
        display_binary(t.microsecond /10000, 6, hundrefths_color)
        time.sleep(0.0001)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <errno.h>


/*
    gcc -Wall -Wextra -pedantic -std=c11 -Os -o "memspeed" "memspeed.c" (im Verzeichnis: /tmp)
    Kompilierung erfolgreich beendet.
*/


#define ALLOC_SIZE (1024L*1024L*1024L)


void writeMemory(char *p) {
    struct itimerval start_value;
    struct itimerval end_value;
    long t;


    start_value.it_interval.tv_sec = 100;
    start_value.it_interval.tv_usec = 0;
    start_value.it_value.tv_sec = 100;
    start_value.it_value.tv_usec = 0;


    int rc1 = setitimer(ITIMER_REAL, &start_value, NULL);
    memset(p, 'A', ALLOC_SIZE);
    int rc2 = getitimer(ITIMER_REAL, &end_value);


    if (rc1 || rc2)
        perror("Timer error");


    t = (start_value.it_value.tv_sec - end_value.it_value.tv_sec) * 1000000;
    t -= end_value.it_value.tv_usec;


    printf("%ld µs\n", t);
}


void memVerify(char *p) {
    for(long i = 0; i < ALLOC_SIZE; i++) {
        if (p[i] != 'A') {
            puts("Data error");
            return;
        }
    }
}


int main(void) {
    char *p = NULL;


    p = malloc(ALLOC_SIZE);
    if (p) {
        writeMemory(p);
        writeMemory(p);
        writeMemory(p);
        writeMemory(p);
        writeMemory(p);
        memVerify(p);
        free(p);
    }
    return 0;
}

################################
# Backup Script AIO	       #
# Author Tobias Koehler        # 
# Mail: tk1908@gmail.com       #       
# Version 2.1                  #                            
################################


#!/bin/bash


parameter=$1


CURRENT_CLIENT="${HOME}/.backup.current"
CURRENT_SERVER="/data/nuketown/misc/.backup/.backup_current"
DAY="$(date +%F)"




# Syncronisierung von Dokumenten, auf ares nach athene liegen.
# Ausdrückliche Warnung! Dokumente, welche auf nexus neuer sind, als auf nuketown, werden mittels --delete gelöscht!


clean() {
  find /home/tkoehler/Musik/ -type f \(  -iname "Thumbs.db" \) -exec rm -rf {} \;
  find /home/tkoehler/Dokumente/Beruflich/Bewerbungsunterlagen/Erledigt/ -type d \(  -iname "pictures" \) -exec rm -rf {} \;
  find /home/tkoehler/Dokumente/Beruflich/Bewerbungsunterlagen/Erledigt/ -type f \( ! -iname "*.pdf" \) -exec rm -rf {} \;
  find /home/tkoehler/Dokumente/Privat/persönliches/ -type f \( ! -iname "*.tex" \) -exec rm -rf {} \;
}


servsync() {
  rsync -rvu /mnt/nuketown/
}




clientbackup() {
  echo Cleaning
  clean
  rsync -rvu --link-dest=/data/nuketown/misc/.backup/.backup_current ${HOME}/Dokumente/ /data/nuketown/misc/Dokumente/ --delete
  rsync -rvu ${HOME}/Downloads /data/nuketown/misc/Incomming/
  rsync -rvu ${HOME}/Musik/ /data/nuketown/music/
}


clientsync() {
  rsync -rvu /data/nuketown/misc/Dokumente/ ${HOME}/Dokumente
  rsync -rvu /data/nuketown/music/ ${HOME}/Musik
}


rotate() {
  mkdir /data/nuketown/misc/.backup/.backup_$DAY
}




case $parameter in
      servsync) servsync
      ;;
      
      clientbackup) clientbackup
      ;;
      
      clientsync) clientsync
      ;;
      


      rotate) rotate
      ;;


      clean) clean
      ;;




      *) echo Es stehen nur die Funktionen servsync, clientbackup, clientsync, rotate und clean zur Verfügung!
      ;;
esac