void redisplayStaffInfoIfNecessary(bit instanceFlag){
if(inSetting==1){
return;
}
if(isSetted==1){
if((instanceFlag==1)){
displayStaffInfo();
}
}
showAddress(13,1);
}
int main(int argc, char** argv) {
char buf[BUFLEN], rbuf[BUFLEN]; // transmitter and receiver buffers
SOCKET s; // socket
struct in_addr sIPaddr; // server IP address structure
struct sockaddr_in saddr; // server address structure
uint16_t tport_n, tport_h; // server port number by htons()
char filename[FILELEN+1], fileDwnld[FILELEN+1], c1, c2;
FILE* fp;
int nread, fileCounter=0, readFileFlag=0, endFlag=0;
uint32_t fileBytes, filePointer, timeStamp;
fd_set cset;
/* Check number of arguments */
checkArg(argc, 3);
/* Set IP address and port number of Server */
setIParg(argv[1], &sIPaddr);
tport_n = setPortarg(argv[2], &tport_h);
/* Create the socket */
fprintf(stdout, "Creating the socket...\n");
s = Socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
fprintf(stdout, "- OK. Socket fd: %d\n", s);
/* Prepare server address structure */
saddr.sin_family = AF_INET;
saddr.sin_port = tport_n;
saddr.sin_addr = sIPaddr;
/* Send connection request */
fprintf(stdout, "Connecting to target address...\n");
Connect(s, (struct sockaddr*) &saddr, sizeof(saddr));
fprintf(stdout, "- OK. Connected to ");
showAddress(&saddr);
br();
/* Ready to accept commands */
fprintf(stdout, "Input a command: GET file, Q, A:\n");
/* Main */
while(1) {
if ((readFileFlag == 0) && (endFlag == 1)) {
break;
}
/* Set socket and stdin */
FD_ZERO(&cset);
FD_SET(s, &cset);
FD_SET(fileno(stdin), &cset);
Select(s+1, &cset, NULL, NULL, NULL);
/* The socket is readable */
if (FD_ISSET(s, &cset)) {
if (readFileFlag == 0) {
/* Response from server */
nread = 0;
do {
Read(s, &c1, sizeof(char));
rbuf[nread++] = c1;
} while((c1 != '\n') && (nread < BUFLEN-1));
rbuf[nread] = '\0';
while((nread > 0) && ((rbuf[nread-1] == '\r') || (rbuf[nread-1] == '\n'))) {
rbuf[nread-1] = '\0';
nread--;
}
/* Compute the type of message received and behave according to it */
if ((nread >= strlen(MSG_OK)) && (strncmp(rbuf, MSG_OK, strlen(MSG_OK)) == 0)) {
// OK, right response received
fprintf(stdout, "--- +OK message received.\n");
sprintf(fileDwnld, "Dwnld_%d", fileCounter); // filename of received file
fileCounter++;
// Read the file size
Read(s, rbuf, sizeof(uint32_t));
fileBytes = ntohl(*(uint32_t*)rbuf);
fprintf(stdout, "--- File size: %u\n", fileBytes);
// Read the file timestamp
Read(s, rbuf, sizeof(uint32_t));
timeStamp = ntohl(*(uint32_t*)rbuf);
fprintf(stdout, "--- File timestamp: %u\n", timeStamp);
// Open file for writing
fp = Fopen(fileDwnld, "wb");
readFileFlag = 1;
filePointer = 0;
fprintf(stdout, "--- File %s opened for writing...\n", fileDwnld);
} else if ((nread >= strlen(MSG_ERR)) && (strncmp(rbuf, MSG_ERR, strlen(MSG_ERR)) == 0)) {
// ERROR
fprintf(stderr, "--- ERROR. Message received: %s.\n", rbuf);
break;
} else {
// ERROR
fprintf(stderr, "--- ERROR. Something goes wrong with the communication protocol.\n");
break;
}
} else if (readFileFlag == 1) {
/* Read a character from the buffer and write it into the file */
Read(s, &c2, sizeof(char));
Fwrite(&c2, sizeof(char), 1, fp);
filePointer++;
/* Check if EOF */
if (filePointer == fileBytes) {
Fclose(fp);
fprintf(stdout, "--- File received and written: %s\n", fileDwnld);
readFileFlag = 0;
}
} else {
// ERROR
fprintf(stderr, "--- ERROR. Something goes wrong with the readFileFlag.\n");
break;
}
}
/* The stdin is readable */
if (FD_ISSET(fileno(stdin), &cset)) {
if (fgets(buf, BUFLEN, stdin) == NULL) {
buf[0] = 'Q';
}
switch(buf[0]) {
case 'G':
case 'g':
sscanf(buf, "%*s %s", filename);
sprintf(buf, "GET %s\r\n", filename);
Write(s, buf, strlen(buf)*sizeof(char));
fprintf(stdout, "- GET command sent.\n");
break;
case 'Q':
case 'q':
sprintf(buf, MSG_QUIT);
Write(s, buf, strlen(buf)*sizeof(char));
fprintf(stdout, "- Q command sent.\n");
Shutdown(s, SHUT_WR);
endFlag = 1;
fprintf(stdout, "--- Waiting for file transfer to terminate...\n");
return 0;
case 'A':
case 'a':
fprintf(stdout, "--- Closing connection immediately...\n");
closesocket(s);
fprintf(stdout, "--- OK. Closed.\n");
return 0;
default:
fprintf(stdout, "- Unknown command %c.\n", buf[0]);
break;
}
}
}
br();
/* Close the socket connection */
fprintf(stdout, "Closing the socket connection...\n");
closesocket(s);
fprintf(stdout, "- OK. Closed.\n");
return 0;
}
MemoryEditor::MemoryEditor() {
setObjectName("memory-editor");
setWindowTitle("Memory Editor");
setGeometryString(&config().geometry.memoryEditor);
application.windowList.append(this);
layout = new QGridLayout;
layout->setMargin(Style::WindowMargin);
layout->setSpacing(Style::WidgetSpacing);
setLayout(layout);
editor = new QHexEdit;
editor->reader = { &MemoryEditor::reader, this };
editor->writer = { &MemoryEditor::writer, this };
editor->usage = { &MemoryEditor::usage, this };
memorySource = SNES::Debugger::MemorySource::CPUBus;
layout->addWidget(editor, 0, 0);
controlLayout = new QVBoxLayout;
controlLayout->setSpacing(0);
layout->addLayout(controlLayout, 0, 1);
layout->setColumnStretch(0, 1);
source = new QComboBox;
source->addItem("S-CPU bus");
source->addItem("S-APU bus");
source->addItem("S-PPU VRAM");
source->addItem("S-PPU OAM");
source->addItem("S-PPU CGRAM");
source->addItem("Cartridge ROM");
source->addItem("Cartridge RAM");
source->addItem("SA-1 bus");
source->addItem("GSU bus");
controlLayout->addWidget(source);
controlLayout->addSpacing(2);
addr = new QLineEdit;
controlLayout->addWidget(addr);
autoUpdateBox = new QCheckBox("Auto update");
controlLayout->addWidget(autoUpdateBox);
refreshButton = new QPushButton("Refresh");
controlLayout->addWidget(refreshButton);
toolLayout = new QHBoxLayout;
controlLayout->addLayout(toolLayout);
#define tool(widget, icon, text, slot, accel) \
widget = new QToolButton; \
toolLayout->addWidget(widget); \
widget->setAutoRaise(true); \
widget->setDefaultAction(new QAction(this)); \
widget->defaultAction()->setIcon(QIcon(":16x16/mem-" icon ".png")); \
widget->defaultAction()->setToolTip(text); \
widget->defaultAction()->setShortcut(accel); \
connect(widget->defaultAction(), SIGNAL(triggered()), this, SLOT(slot()))
tool(prevCodeButton, "prev-code", "Previous Code", prevCode, 0);
tool(nextCodeButton, "next-code", "Next Code", nextCode, 0);
tool(prevDataButton, "prev-data", "Previous Data", prevData, 0);
tool(nextDataButton, "next-data", "Next Data", nextData, 0);
tool(prevUnkButton, "prev-unknown", "Previous Unknown", prevUnknown, 0);
tool(nextUnkButton, "next-unknown", "Next Unknown", nextUnknown, 0);
toolLayout->addStretch();
toolLayout = new QHBoxLayout;
controlLayout->addLayout(toolLayout);
tool(findButton, "find", "Find in Memory (Ctrl+F)", search, Qt::Key_F | Qt::CTRL);
// TODO: other icons for these maybe
tool(findPrevButton, "prev-unknown", "Find again up (Shift+F3)", searchPrev, Qt::Key_F3 | Qt::SHIFT);
tool(findNextButton, "next-unknown", "Find again down (F3)", searchNext, Qt::Key_F3);
toolLayout->addStretch();
#undef tool
spacer = new QWidget;
spacer->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
controlLayout->addWidget(spacer);
exportButton = new QPushButton("Export");
controlLayout->addWidget(exportButton);
importButton = new QPushButton("Import");
controlLayout->addWidget(importButton);
statusBar = new QLabel;
layout->addWidget(statusBar, 1, 0, 1, 2);
connect(editor, SIGNAL(currentAddressChanged(qint64)), this, SLOT(showAddress(qint64)));
connect(source, SIGNAL(currentIndexChanged(int)), this, SLOT(sourceChanged(int)));
connect(addr, SIGNAL(textEdited(const QString&)), this, SLOT(updateOffset()));
connect(addr, SIGNAL(returnPressed()), this, SLOT(updateOffset()));
connect(refreshButton, SIGNAL(released()), this, SLOT(refresh()));
connect(exportButton, SIGNAL(released()), this, SLOT(exportMemory()));
connect(importButton, SIGNAL(released()), this, SLOT(importMemory()));
sourceChanged(0);
}
int main(int argc, char** argv) {
SOCKET s, s_acceptor; // socket and acceptor socket
struct sockaddr_in saddr, caddr; // server and client address structures
uint16_t lport_n, lport_h; // server port number by htons()
int backlog = 2; // pending requests queue length
socklen_t caddr_len; // client address length
int retValue; // service() returning status
int i;
/* Check number of arguments */
checkArg(argc, 3);
/* The number of children */
n_children = atoi(argv[2]);
if (n_children > 10) {
fprintf(stderr, "- ERROR. Children must be at most 10.\n");
return -1;
}
/* Alloc memory for pids */
pids = (pid_t*)malloc(n_children*sizeof(pid_t));
if (pids == NULL) {
fprintf(stderr, "- ERROR allocating pids.\n");
return -1;
}
/* Instantiate a signal handler for SIGINT */
Signal(SIGINT, sigintHandler);
/* Initialize the socket API (only for Windows) */
SockStartup();
/* Set port number */
lport_n = setPortarg(argv[1], &lport_h);
/* Create the socket */
fprintf(stdout, "Creating the socket...\n");
s = Socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
fprintf(stdout, "- OK. Socket fd: %d\n", s);
/* Prepare server address structure */
saddr.sin_family = AF_INET;
saddr.sin_port = lport_n;
saddr.sin_addr.s_addr = INADDR_ANY;
/* Bind the socket to a local network address */
fprintf(stdout, "Binding the socket...\n");
Bind(s, (struct sockaddr*) &saddr, sizeof(saddr));
fprintf(stdout, "- OK. Socket bound.\n");
/* Listen to connection requests */
fprintf(stdout, "Listen at socket %d with backlog = %d...\n", s, backlog);
Listen(s, backlog);
fprintf(stdout, "- OK. Socket is listening on ");
showAddress(&saddr);
for (i=0; i<n_children; i++) {
if ((pids[i] = fork()) < 0) {
fprintf(stderr, "- ERROR. fork() failed.\n");
} else if ((pids[i]) > 0) {
// The parent
} else {
// The child
while(1) {
/* Accept connection requests */
br();
caddr_len = sizeof(struct sockaddr_in);
s_acceptor = Accept(s, (struct sockaddr*) &caddr, &caddr_len);
fprintf(stdout, "- New connection from client ");
showAddress(&caddr);
retValue = service(s_acceptor);
closesocket(s_acceptor);
fprintf(stdout, "--- Connection closed by %s", (retValue == 0) ? "client\n" : "server\n");
br();
}
}
}
while(1) {
pause();
}
return 0;
}
int main(int argc, char** argv) {
char rbuf[MAXBUF]; // transmitter and receiver buffers
SOCKET s; // socket
struct in_addr sIPaddr; // server IP address structure
struct sockaddr_in saddr; // server address structure
uint16_t tport_n, tport_h; // server port number by htons()
char *filename;
FILE* fp;
uint32_t fileBytesN, fileBytes, nNext, nLeft;
ssize_t nread, nwritten;
XDR xdrs_in; // Input XDR stream
XDR xdrs_out; // Output XDR stream
FILE* stream_socket_r; // FILE stream for reading from the socket
FILE* stream_socket_w; // FILE stream for writing to the socket
call_msg reqMessage;
response_msg resMessage;
/* Check number of arguments */
checkArg(argc, 4);
prog_name = argv[0];
/* Set IP address */
setIParg(argv[1], &sIPaddr);
/* Set port number */
tport_n = setPortarg(argv[2], &tport_h);
/* Save the file to request */
filename = argv[3];
/* Create the socket */
fprintf(stdout, "Creating the socket...\n");
s = Socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
fprintf(stdout, "- OK. Socket fd: %d\n", s);
/* Prepare server address structure */
saddr.sin_family = AF_INET;
saddr.sin_port = tport_n;
saddr.sin_addr = sIPaddr;
/* Send connection request */
fprintf(stdout, "Connecting to target address...\n");
Connect(s, (struct sockaddr*) &saddr, sizeof(saddr));
fprintf(stdout, "- OK. Connected to ");
showAddress(&saddr);
/* Open FILE reading stream and bind it to the corresponding XDR stream */
stream_socket_r = fdopen(s, "r");
if (stream_socket_r == NULL) {
fprintf(stderr, "---ERROR. fdopen() failed.\n");
return 1;
}
xdrstdio_create(&xdrs_in, stream_socket_r, XDR_DECODE);
/* Open FILE writing stream and bind it to the corresponding XDR stream */
stream_socket_w = fdopen(s, "w");
if (stream_socket_w == NULL) {
fprintf(stderr, "---ERROR. fdopen() failed.\n");
xdr_destroy(&xdrs_in);
fclose(stream_socket_r);
return 1;
}
xdrstdio_create(&xdrs_out, stream_socket_w, XDR_ENCODE);
while(1) {
/* Send a file request */
reqMessage.ctype = GET;
reqMessage.call_msg_u.filename = filename;
if (!xdr_call_msg(&xdrs_out, &reqMessage)) {
fprintf(stdout, "- ERROR sending GET message.\n");
break;
}
fflush(stream_socket_w);
/* Receive a message */
if (!xdr_response_msg(&xdrs_in, &resMessage)) {
fprintf(stdout, "- ERROR. Response xdr_response_msg() failed.\n");
break;
}
fprintf(stdout, "- Received response.\n");
if (resMessage == OK) {
fprintf(stdout, "- File received: %s\n", filename);
// Read the file size
nread = read(s, (void*)&fileBytesN, sizeof(uint32_t));
fileBytes = ntohl(fileBytesN);
fprintf(stdout, "- File size: %u\n", fileBytesN);
// Received and write file
fp = Fopen(filename, "wb");
nLeft = fileBytes;
while(nLeft > 0) {
if (nLeft < MAXBUF) {
nNext = nLeft;
} else {
nNext = MAXBUF;
}
nread = Read(s, rbuf, nNext*sizeof(char));
nwritten = Fwrite(rbuf, sizeof(char), nNext, fp);
if (nread != nNext || nwritten != nNext) {
fprintf(stdout, "--- ERROR saving file.\n");
break;
}
nLeft -= nNext;
}
Fclose(fp);
fprintf(stdout, "--- File written: %s\n", filename);
} else if (resMessage == ERR) {
fprintf(stderr, "- Received ERR message.\n");
break;
} else {
fprintf(stderr, "- ERROR. Something goes wrong with the communication protocol.\n");
break;
}
/* End the communication */
reqMessage.ctype = QUIT;
reqMessage.call_msg_u.filename = NULL;
if (!xdr_call_msg(&xdrs_out, &reqMessage)) {
fprintf(stdout, "- ERROR sending QUIT message.\n");
break;
}
fprintf(stdout, "- QUIT message sent.\n");
fflush(stream_socket_r);
fflush(stream_socket_w);
break;
}
xdr_destroy(&xdrs_in);
fclose(stream_socket_r);
xdr_destroy(&xdrs_out);
fclose(stream_socket_w);
/* Close the socket connection */
fprintf(stdout, "Closing the socket connection...\n");
closesocket(s);
fprintf(stdout, "- OK. Closed.\n");
return 0;
}
