int main(int argc, char *argv[])
{
char stringToPrint[64];
clearScreen();
initNetwork();
sprintf(stringToPrint,"Hallo, dies ist ein Test! !\"$%&/()=?),.-;:_#'`*+~");
putString(stringToPrint,COLOR_RED);
putString(" :-) :-D ",COLOR_GREEN);
putString("Einiges noch zu tun!",COLOR_AMBER);
updateDisplay(client_sock);
sleep(1);
while(1)
{
shiftLeft();
updateDisplay(client_sock);
usleep(20000);
}
close(client_sock);
return 0;
}
void
getNet_from_config(char* dirname,
char * degfilename,
char * graphfilename,
int nodeNum )
{
int i;
int j;
int adj;
int node;
struct network* target;
char path1[200];
int *degree;
FILE * graphFile;
FILE * netFile;
int error;
// 1) read the network data from the degfilename file
strcpy(path1,dirname);
strcat(path1,degfilename);
getDegreeSequence(path1, nodeNum, °ree);
printf("herere ---- \n");
target=(struct network *)mem_alloc(sizeof(struct network));
initNetwork(target, nodeNum, 0);
strcpy(path1,dirname);
strcat(path1,graphfilename);
graphFile = fopen(path1, "r");
i=1;
while(1)
{
error=fscanf(graphFile, "%d ", &node);
if(error==-1)
{
break;
}
for(j=1;j<=degree[i];j++)
{
error=fscanf(graphFile, "%d ", &adj);
error=0;
error+=addLinkToNetwork(target, node+1, adj+1, 1.0);
error+=addLinkToNetwork(target, adj+1, node+1, 1.0);
}
i++;
}
fclose(graphFile);
strcat(path1,"_net.txt");
netFile=fopen(path1,"w");
outputNetwork(target, netFile);
fclose(netFile);
freeNetwork(target);
mem_free(degree);
}
int _main(void) {
// Init and resolve libraries
initKernel();
initLibc();
initNetwork();
// Connect to server and send message
char socketName[] = "debug";
struct sockaddr_in server;
server.sin_len = sizeof(server);
server.sin_family = AF_INET;
server.sin_addr.s_addr = IP(192, 168, 0, 4);
server.sin_port = sceNetHtons(9023);
memset(server.sin_zero, 0, sizeof(server.sin_zero));
int sock = sceNetSocket(socketName, AF_INET, SOCK_STREAM, 0);
sceNetConnect(sock, (struct sockaddr *)&server, sizeof(server));
debug(sock, "PID: %d", syscall(20));
sceNetSocketClose(sock);
// Return to browser
return 0;
}
void startApplication(void *pvParameters) {
// init the network state
initNetwork();
// init the Parse app config
short status = initConfig();
if (status < 0) {
// not configured, start configuration mode
startConfigurationMode();
} else {
// configured, start application mode
startApplicationMode();
setBoardTimeFromNtp();
initParseClient();
// update Led state to parse
saveLedState();
// start the Parse push service
status = startPushServiceTask();
if (status < 0) {
UART_PRINT("[Blink] Start push service task error\r\n");
ERR_PRINT(status);
}
// configure and enable the board buttons
enableButtons();
// run the message loop
applicationMessageLoop();
}
}
int main( int argc, char *argv[] ) {
//get args
get_args(argc, argv);
initDefaultSettings();
//read settings file
ReadConfigFile();
//init system
SystemInit(&argc,argv);
initNetwork();
//starting the tracker
start_tracker();
while(1) {
//parse network
handle_tracker();
check_serveractivity();
#ifdef macintosh
mac_yield_cpu (10000);
#else
SDL_Delay(10);
#endif
}
stop_tracker();
//cleanup
return 0;
}
/**
* \brief Default Constructor
*
* Initializes Aquaduino with default values and then tries to read the
* configuration using the SDConfigManager. When there are multiple
* implementations of ConfigManager available this is the place to exchange
* them. Finally the network is brought up.
*/
Aquaduino::Aquaduino() :
m_IP(192, 168, 1, 222), m_Netmask(255, 255, 255, 0), m_DNSServer(192,
168, 1, 1), m_Gateway(192, 168, 1, 1), m_NTPServer(192, 53, 103,
108), m_Timezone(TIME_ZONE), m_NTPSyncInterval(5), m_DHCP(0), m_NTP(
0), m_Xively(0), m_Controllers(MAX_CONTROLLERS), m_Actuators(
MAX_ACTUATORS), m_Sensors(MAX_SENSORS), m_XivelyClient(ethClient) {
__aquaduino = this;
m_Type = AQUADUINO;
initPeripherals();
Serial.print(F("Startup Free Ram: "));
Serial.println(freeRam());
//ToDo: Buggy!
m_ConfigManager = new SDConfigManager();
readConfig(this);
initNetwork();
initXively();
#ifdef INTERRUPT_DRIVEN
Serial.println("Interrupt triggered mode enabled.");
startTimer();
#else
Serial.println("Software triggered mode enabled.");
#endif
}
void startApplication(void *pvParameters) {
// TODO: Change to your SSID and password
signed char ssid[] = "<wifi ssid>";
signed char key[] = "<wifi password>";
SlSecParams_t keyParams;
keyParams.Type = SL_SEC_TYPE_WPA;
keyParams.Key = key;
keyParams.KeyLen = strlen((char *)key);
initNetwork(ssid, &keyParams);
// TODO: Set to current date/time (within an hour precision)
SlDateTime_t dateTime;
memset(&dateTime, 0, sizeof(dateTime));
dateTime.sl_tm_year = 2015;
dateTime.sl_tm_mon = 3;
dateTime.sl_tm_day = 20;
dateTime.sl_tm_hour = 12;
sl_DevSet(SL_DEVICE_GENERAL_CONFIGURATION, SL_DEVICE_GENERAL_CONFIGURATION_DATE_TIME, sizeof(SlDateTime_t), (unsigned char *)&dateTime);
UART_PRINT("\r\n");
UART_PRINT("[QuickStart] Start application\r\n");
UART_PRINT("\r\n");
// TODO: Add Parse code here
}
void
kshell_test()
{
int *shell;
struct network * target;
int i;
target=NULL;
target=(struct network *)mem_alloc(sizeof(struct network));
initNetwork(target, 3, UN_DIRECT_UN_WEIGHT);
// link info
addLinkToNetwork(target,1,2,1.0);
addLinkToNetwork(target,2,1,1.0);
addLinkToNetwork(target,2,3,1.0);
addLinkToNetwork(target,3,2,1.0);
shell=(int *)mem_alloc((1+target->nodeNum)*sizeof(int));
getKshell(target, shell);
for(i=1;i<=target->nodeNum;i++)
{
printf("node %d : shell %d \n",i,shell[i]);
}
freeNetwork(target);
mem_free(shell);
}
Client::Client(const std::string& applicationName, const Settings& settings,
OSWindow* osWindow, shared_ptr<GuiTheme> theme) :
GuiWindow("Server Browser", theme,
Rect2D::xywh(100, 100, 500, 500), GuiTheme::NO_WINDOW_STYLE, NO_CLOSE),
m_settings(settings),
m_osWindow(osWindow),
m_applicationName(applicationName) {
initNetwork();
if (theme) {
if (isNull(m_settings.displayStyle.font)) {
m_settings.displayStyle.font = theme->defaultStyle().font;
}
if (m_settings.displayStyle.color.r == -1) {
m_settings.displayStyle.color = theme->defaultStyle().color;
}
if (m_settings.displayStyle.outlineColor.r == -1) {
m_settings.displayStyle.outlineColor = theme->defaultStyle().outlineColor;
}
if (m_settings.displayStyle.size == -1) {
m_settings.displayStyle.size = theme->defaultStyle().size;
}
}
m_display.reset(new Display());
m_display->client = this;
m_connectPushed = false;
m_index = 0;
if (osWindow != NULL) {
// Fill the screen
setRect(osWindow->clientRect());
}
}
int _main(void)
{
// Init and resolve libraries
initKernel();
initLibc();
initNetwork();
initPthread();
// Init netdebug
struct sockaddr_in server;
server.sin_family = sceNetHtons(AF_INET);
server.sin_addr.s_addr = IP(192, 168, 0, 4);
server.sin_port = sceNetHtons(9023);
memset(server.sin_zero, 0, sizeof(server.sin_zero));
netdbg_sock = sceNetSocket("netdebug", AF_INET, SOCK_STREAM, 0);
sceNetConnect(netdbg_sock, (struct sockaddr *)&server, sizeof(server));
ftp_init(PS4_IP, PS4_PORT);
//INFO("PS4 listening on IP %s Port %i\n", PS4_IP, PS4_PORT);
while (1) {
sceKernelUsleep(100 * 1000);
}
ftp_fini();
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
initCommon();
if (initConfig()==0){
destroyConfig();
return 1;
};
scanPorts();
/*
#define STATUS_OK 0x000
#define STATUS_HARDWARE_NOT_CONNECTED 0x001
#define STATUS_HARDWARE_ON_DIFFERENT_PORT 0x002 //the hardware was detected on a different port
#define STATUS_USER_HARDWARE_SELECTION 0x004
*/
if (resolveConfig() & (STATUS_HARDWARE_NOT_CONNECTED | STATUS_USER_HARDWARE_SELECTION)){
return 1;//error abort
};
initSerialCommunication();
if (initNetwork()==0){
destroyNetwork();
}
test();
closeSerialCommunication();
destroyConfig();
return 0;
}
void
StationsPluginSimple::request(const QUrl & url, int id, const QByteArray & data)
{
if (url.isEmpty())
return ;
qDebug() << "Loading url" << url.toString()
<< "( online:" << Tools::isOnline() << ")";
QNetworkReply *rep;
QNetworkRequest req(url);
initNetwork();
Tools::fixupRequest(&req);
if (data.isEmpty())
rep = nm->get(req);
else {
req.setHeader(QNetworkRequest::ContentTypeHeader,
"application/x-www-form-urlencoded");
rep = nm->post(req, data);
}
connect(rep, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(networkError(QNetworkReply::NetworkError)));
if (count == 0) {
emit started();
step = 0;
}
replies[rep] = id;
count++;
}
//-------------------------------------------------------------------------------------
bool Machine::initializeBegin()
{
if(!initNetwork())
return false;
return true;
}
QUHttpCollector::QUHttpCollector(QUSongInterface *song, QUMultilingualImageSource *source): QObject(source) {
_song = song;
_source = source;
_communicator = 0;
ignoredUrls = 0;
initNetwork();
setState(Idle);
}
Client::Client(const std::string& applicationName, const Settings& settings) :
m_settings(settings),
m_osWindow(NULL),
m_applicationName(applicationName),
m_index(0),
m_connectPushed(false) {
initNetwork();
}
int _main(void) {
// Init and resolve libraries
initKernel();
initLibc();
initNetwork();
// Connect to server
char socketName[] = "debug";
struct sockaddr_in server;
server.sin_len = sizeof(server);
server.sin_family = AF_INET;
server.sin_addr.s_addr = IP(192, 168, 0, 4);
server.sin_port = sceNetHtons(9023);
memset(server.sin_zero, 0, sizeof(server.sin_zero));
int sock = sceNetSocket(socketName, AF_INET, SOCK_STREAM, 0);
sceNetConnect(sock, (struct sockaddr *)&server, sizeof(server));
// Get font path
char path[256] = "/";
int length = 11;
getSandboxDirectory(path + 1, &length);
strcpy(path + 11, "/common/font/DFHEI5-SONY.ttf");
// Open for reading, and get size
int fd = open(path, O_RDONLY, 0);
struct stat s;
fstat(fd, &s);
// Allocate buffer and read
char *buffer = malloc(s.st_size);
read(fd, buffer, s.st_size);
close(fd);
// Send
sceNetSend(sock, buffer, s.st_size, 0);
free(buffer);
sceNetSocketClose(sock);
// Return to browser
return 0;
}
int main(int argc, char ** argv) {
initNetwork();
struct epoll_event ev;
memset(&ev, 0, sizeof (struct epoll_event));
int epollfd;
epollfd = epoll_create(10);
FAIL(epollfd);
//Ajout à epoll de l'entrée standard
ev.events = EPOLLIN;
ev.data.fd = STDIN_FILENO;
FAIL(epoll_ctl(epollfd, EPOLL_CTL_ADD, STDIN_FILENO, &ev));
struct epoll_event events[MAX_EVENTS];
int nfds;
int done = 0;
while (done == 0) //Boucle principale
{
do {
nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
} while(errno == EINTR);
FAIL(nfds);
int n;
for (n = 0; n < nfds; ++n) {
if (events[n].data.fd == STDIN_FILENO) {
char chaine[16];
fgets(chaine, 15, stdin); //récupère l'entrée standard
//Traite la commande
if (strcmp(chaine, "exit\n") == 0 || strcmp(chaine, "quit\n") == 0 || strcmp(chaine, "q\n") == 0) {
done = 1;
puts("Quiting simulator!");
}
else {
puts("Commande invalide\nUsage: exit, quit, q");
}
}
}
}
closeNetwork();
return 0;
}
int _main(void) {
// Pass address of a syscall gadget in rcx
register f rcx asm("rcx");
directSyscall = rcx;
// Init and resolve libraries
initLibc();
initNetwork();
// Connect to server and send message
char socketName[] = "debug";
struct sockaddr_in server;
server.sin_family = sceNetHtons(AF_INET);
server.sin_addr.s_addr = IP(192, 168, 0, 4);
server.sin_port = sceNetHtons(9023);
memset(server.sin_zero, 0, sizeof(server.sin_zero));
int sock = sceNetSocket(socketName, AF_INET, SOCK_STREAM, 0);
sceNetConnect(sock, (struct sockaddr *)&server, sizeof(server));
char buffer[512];
struct dirent *dent;
int dfd = open("/", O_RDONLY, 0);
if(dfd < 0) {
debug(sock, "Invalid directory.\n");
return 1;
}
while(getdents(dfd, buffer, sizeof(buffer)) != 0) {
dent = (struct dirent *)buffer;
while(dent->d_fileno) {
debug(sock, "%s\n", dent->d_name);
dent = (struct dirent *)((void *)dent + dent->d_reclen);
}
memset(buffer, 0, sizeof(buffer));
}
// Return to browser
close(dfd);
sceNetSocketClose(sock);
return 0;
}
int main() {
int n, m, k;
while (EOF != scanf("%d%d%d", &n, &m, &k)) {
if (n == 0 && m == 0 && k == 0) break;
memset(n_sum, 0, sizeof(n_sum));
memset(h_sum, 0, sizeof(h_sum));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < k; ++j) {
scanf("%d", &need[i][j]);
n_sum[j] += need[i][j];
}
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < k; ++j) {
scanf("%d", &have[i][j]);
h_sum[j] += have[i][j];
}
}
bool can = true;
for (int i = 0; i < k; ++i) {
if (h_sum[i] < n_sum[i]) {
can = false;
break;
}
}
int cost, flow, ans = 0;
int source = n+m, sink = n+m+1;
for (int c = 0, w; c < k; ++c) {
if (can) initNetwork(n+m+2);
for (int a = 0; a < n; ++a) {
for (int b = 0; b < m; ++b) {
scanf("%d", &w);
if (can) addEdge(b, m+a, INF, w);
}
}
if (!can) continue;
for (int i = 0; i < m; ++i) {
addEdge(source, i, have[i][c], 0);
}
for (int i = 0; i < n; ++i) {
addEdge(m+i, sink, need[i][c], 0);
}
mincost_maxflow(n+m+2, source, sink, flow, cost);
ans += cost;
}
if (can) {
printf("%d\n", ans);
} else {
puts("-1");
}
}
return 0;
}
int _main(void) {
// Init and resolve libraries
initLibc();
initNetwork();
// Connect to server
char socketName[] = "debug";
struct sockaddr_in server;
server.sin_len = sizeof(server);
server.sin_family = AF_INET;
server.sin_addr.s_addr = IP(192, 168, 0, 4);
server.sin_port = sceNetHtons(9023);
memset(server.sin_zero, 0, sizeof(server.sin_zero));
int sock = sceNetSocket(socketName, AF_INET, SOCK_STREAM, 0);
sceNetConnect(sock, (struct sockaddr *)&server, sizeof(server));
// Read / directory
char buffer[512];
struct dirent *dent;
int dfd = open("/", O_RDONLY, 0);
if(dfd < 0) {
debug(sock, "Invalid directory.\n");
return 1;
}
while(getdents(dfd, buffer, sizeof(buffer)) != 0) {
dent = (struct dirent *)buffer;
while(dent->d_fileno) {
debug(sock, "[%s]: %s\n", entryName(dent->d_type), dent->d_name);
dent = (struct dirent *)((void *)dent + dent->d_reclen);
}
memset(buffer, 0, sizeof(buffer));
}
// Return to browser
close(dfd);
sceNetSocketClose(sock);
return 0;
}
//------------------------------------------------------------------------------
// frameSync() - Trigger the frame update
//------------------------------------------------------------------------------
void OtwPC::frameSync()
{
// Initialization
if (!isNetworkInitialized() && !didInitializationFail()) {
if (initNetwork()) {
netInit = true;
netInitFail = false;
}
else {
netInit = false;
netInitFail = true;
}
}
}
int main(int argc, char** argv){
struct timespec t = {.tv_sec=0};
struct timespec lastTime = {.tv_sec = 0, .tv_nsec = 0};
struct timespec otherTime = {.tv_sec = 0, .tv_nsec = 0};
SDL_Event evnt;
if(argc < 2){
puts("Please specify an ip.");
return 5;
}
if(initView){
puts("no SDL2 window");
return 1;
}
initNetwork(argv[1], 1212);
char test[10];
test[0] = 0;
sendto(sockfd, test, 10, 0, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
sendto(sockfd, test, 10, 0, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
while(running){
netListen();
while(SDL_PollEvent(&evnt)){
if(evnt.type == SDL_KEYDOWN){
if(!keyAction(evnt.key.keysym.sym, 1)){
test[0] = 1;
sendto(sockfd, test, 10, 0, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
}
}else if(evnt.type == SDL_KEYUP){
if(!keyAction(evnt.key.keysym.sym, 0)){
test[0] = 1;
sendto(sockfd, test, 10, 0, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
}
}else if(evnt.type == SDL_QUIT){
running = 0;
}
}
clock_gettime(CLOCK_MONOTONIC, &otherTime);
int32_t sleep = (int32_t)(1000000000/50) - (otherTime.tv_nsec-lastTime.tv_nsec) - 1000000001*(otherTime.tv_sec-lastTime.tv_sec);
if(sleep > 0){
t.tv_nsec = sleep;
nanosleep(&t, NULL);
}
clock_gettime(CLOCK_MONOTONIC, &lastTime);
}
SDL_DestroyRenderer(render);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
int main(int argc, char* argv[])
{
/// 判断参数
if (argc > 1) {
printf("usage: acdx\n");
exit(1);
}
/// 初始化Winsock
initNetwork();
printf("Welcome to TurboACD system!\n");
/// 启动ACD实例开始工作(主类ACDX)
// new acd instance start work thread
ACDX::getInstance()->Start();
return 0;
}
int main(int argc, char* argv[]) {
////////////////////////////////////////// RakNet //////////////////////////////////////////////////////
initNetwork(false);
////////////////////////////////////////// OPEN GL //////////////////////////////////////////////////////
// Initialize GLUT
glutInit(&argc, argv);
// Set up some memory buffers for our display
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
// This one allows me to close the network before the program exits after "X" is pressed.
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION);
glutInitWindowPosition(10, 10);
glutInitWindowSize(SCREEN_WIDTH, SCREEN_HEIGHT);
glutCreateWindow("BoizStone");
//glutFullScreen();
// Bind functions
glutReshapeFunc(changeViewPort);
glutDisplayFunc(render);
glutIdleFunc(idleFunction);
glutKeyboardFunc(keyPress);
glutSpecialFunc(specPress);
glutMouseFunc(mouseClick);
glutPassiveMotionFunc(mousePassive);
glutMotionFunc(mouseActive);
// Very important! This initializes the entry points in the OpenGL driver so we can
// call all the functions in the API.
GLenum err = glewInit();
if (GLEW_OK != err) {
fprintf(stderr, "GLEW error");
return 1;
}
if (net_isServer()) { gameData.toggle_turn(); }
srand(time(NULL));
start_game();
glutMainLoop();
closeNetworking();
return 0;
}
int main()
{
int n, m;
while (EOF != scanf("%d%d", &n, &m)) {
initNetwork(n+2);
for (int i = 1, a, b; i <= n; ++i) {
scanf("%d%d", &a, &b);
addEdge(0, i, a, 0);
addEdge(i, n+1, b, 0);
}
for (int i = 0, u, v, w; i < m; ++i) {
scanf("%d%d%d", &u, &v, &w);
addEdge(u, v, w, w);
}
printf("%d\n", maxflow(n+2, 0, n+1));
}
return 0;
}
int main(int argc, char** argv)
{
srand(time(0));
config(&argc, argv);
initNetwork();
initSimulation();
initDisplay(&argc, argv);
for(;;)
{
stepNetwork();
stepSimulation();
stepDisplay();
};
return 0;
}
int main() {
int n, m, s, d;
while (EOF != scanf("%d%d%d%d", &n, &m, &s, &d)) {
--s, --d;
initNetwork(n+n);
for (int i = 0, w; i < n; ++i) {
scanf("%d", &w);
addEdge(i, i+n, w);
}
for (int i = 0, a, b; i < m; ++i) {
scanf("%d%d", &a, &b);
--a, --b;
addEdge(a+n, b, INF);
addEdge(b+n, a, INF);
}
printf("%d\n", maxflow(n+n, s, d+n));
}
return 0;
}
Server::Server(void *surf, const Configuration& conf)
: Framework(surf, conf, UNINITIALIZED), ballouttimer(-1), ballspeed(6.0)
{
ball.push_back(Ball(this));
player.push_back(new Player(this, "Mr. Wand", BACK, field.getLength()/2.0f));
// Mr. Wand is cheating!
player[0]->setSize(3.5, 3.5); // *****************
player[0]->run();
resetScore();
output.addMessage(Interface::WAITING_FOR_OPPONENT);
server = initNetwork(conf.version, conf.playername, conf.port);
loopback = Client::initNetwork(conf.version, "localhost", conf.port, conf.playername);
if (server == -1 || loopback == -1)
shutdown();
loop();
}
void _start(void) {
int sock;
struct sockaddr_in address = {
AF_INET,
port,
ip,
};
initNetwork();
sock = socket("test", AF_INET, SOCK_STREAM, 0);
connect(sock, &address, sizeof(address));
send(sock, message, sizeof(message), 0);
close(sock);
while(1) {
}
}
void
readSNAP_arclist(char *infilename,
int nodeNum,
char *outfilename)
{
FILE * datafile;
FILE * outfile;
struct network* target;
////struct netInfo* netinfo;
////struct CLSTS* clsts;
////FILE * pFile_node;
int totalNum;
int id1;
int id2;
int error;
// 1) read the network data from the raw-data file
target=(struct network *)mem_alloc(sizeof(struct network));
totalNum=nodeNum;
initNetwork(target, totalNum, UN_DIRECT_UN_WEIGHT);
datafile = fopen(infilename, "r");
while(1)
{
error=fscanf(datafile, "%d %d \n", &id1, &id2);
// use (id1 id2) to construct a network
//printf(" %d (%d , %d) %f \n",error, id1,id2,weight);
//getchar();
if(error==-1)
break;
error=addLinkToNetwork(target, id1+1, id2+1, 1.0);
error=addLinkToNetwork(target, id2+1, id1+1, 1.0);
}
fclose(datafile);
outfile=fopen(outfilename, "w");
outputNetwork(target, outfile);
fclose (outfile);
freeNetwork(target);
}
