/* * CrossFire, A Multiplayer game * * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team * Copyright (C) 2001 Mark Wedel * Copyright (C) 1992 Frank Tore Johansen * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * The author can be reached via e-mail to */ /** \file * Image related communication * * \date 2003-12-02 * * This file deals with the image related communication to the * client. I've located all the functions in this file - this * localizes it more, and means that we don't need to declare * things like all the structures as globals. */ #include #include #include "crc.h" #define MAX_FACE_SETS 20 /**< Maximum number of image sets the program will handle */ /** Information about one image */ typedef struct FaceInfo { uint8 *data; /**< image data */ uint16 datalen; /**< length of the xpm data */ uint32 checksum; /**< Checksum of face data */ } FaceInfo; /** Information about one face set */ typedef struct { char *prefix; /**< */ char *fullname; uint8 fallback; /**< faceset to use when an image is not found in this faceset */ char *size; char *extension; char *comment; FaceInfo *faces; /**< images in this faceset */ } FaceSets; static FaceSets facesets[MAX_FACE_SETS]; /**< All facesets */ /** * Checks specified faceset is valid * \param fsn faceset number */ int is_valid_faceset (int fsn) { if (fsn >= 0 && fsn < MAX_FACE_SETS && facesets[fsn].prefix) return TRUE; return FALSE; } /** * Frees all faceset information */ void free_socket_images (void) { int num, q; for (num = 0; num < MAX_FACE_SETS; num++) { if (facesets[num].prefix) { for (q = 0; q < faces.size (); q++) if (facesets[num].faces[q].data) free (facesets[num].faces[q].data); free (facesets[num].prefix); free (facesets[num].fullname); free (facesets[num].size); free (facesets[num].extension); free (facesets[num].comment); free (facesets[num].faces); } } } /** * This returns the set we will actually use when sending * a face. This is used because the image files may be sparse. * This function is recursive. imageno is the face number we are * trying to send * * If face is not found in specified faceset, tries with 'fallback' faceset. * * \param faceset faceset to check * \param imageno image number * */ static int get_face_fallback (int faceset, int imageno) { /* faceset 0 is supposed to have every image, so just return. Doing * so also prevents infinite loops in the case if it not having * the face, but in that case, we are likely to crash when we try * to access the data, but that is probably preferable to an infinite * loop. */ if (faceset == 0) return 0; if (!facesets[faceset].prefix) { LOG (llevError, "get_face_fallback called with unused set (%d)?\n", faceset); return 0; /* use default set */ } if (facesets[faceset].faces[imageno].data) return faceset; return get_face_fallback (facesets[faceset].fallback, imageno); } /** * Checks fallback are correctly defined. * This is a simple recursive function that makes sure the fallbacks * are all proper (eg, the fall back to defined sets, and also * eventually fall back to 0). At the top level, togo is set to MAX_FACE_SETS, * if togo gets to zero, it means we have a loop. * This is only run when we first load the facesets. */ static void check_faceset_fallback (int faceset, int togo) { int fallback = facesets[faceset].fallback; /* proper case - falls back to base set */ if (fallback == 0) return; if (!facesets[fallback].prefix) { LOG (llevError, "Face set %d falls to non set faceset %d\n", faceset, fallback); abort (); } togo--; if (togo == 0) { LOG (llevError, "Infinite loop found in facesets. aborting.\n"); abort (); } check_faceset_fallback (fallback, togo); } #define MAX_IMAGE_SIZE 10000 /** * Client tells us what type of faces it wants. Also sets * the caching attribute. * */ void SetFaceMode (char *buf, int len, client *ns) { int mask = (atoi (buf) & CF_FACE_CACHE), mode = (atoi (buf) & ~CF_FACE_CACHE); if (mode == CF_FACE_NONE) ns->facecache = 1; else if (mode != CF_FACE_PNG) ns->send_packet_printf ("drawinfo %d %s", NDI_RED, "Warning - send unsupported face mode. Will use Png"); if (mask) ns->facecache = 1; } /** * Client has requested pixmap that it somehow missed getting. * This will be called often if the client is * caching images. */ void SendFaceCmd (char *buf, int len, client *ns) { uint16 facenum = atoi (buf); if (facenum != 0) esrv_send_face (ns, facenum, 1); } // how lame static void print_facename (packet &sl, const facedata &d) { for (int i = 0; i < CHKSUM_SIZE; ++i) sl.printf ("%02x", d.chksum [i]); } /** * Sends a face to a client if they are in pixmap mode * nothing gets sent in bitmap mode. * If nocache is true (nonzero), ignore the cache setting from the client - * this is needed for the askface, in which we really do want to send the * face (and askface is the only place that should be setting it). Otherwise, * we look at the facecache, and if set, send the image name. */ void esrv_send_face (client *ns, short face_num, int nocache) { if (face_num <= 0 || face_num >= faces.size ()) { LOG (llevError, "esrv_send_face (%d) out of bounds??\n", face_num); return; } const facedata *d = face_data (face_num, ns->faceset); packet sl; if (ns->facecache && !nocache) { sl << (ns->image2 ? "face2 " : "face1 ") << uint16 (face_num); if (ns->image2) sl << uint8 (0); sl << uint32 (0); // how lame print_facename (sl, *d); ns->send_packet (sl); } else { sl << (ns->image2 ? "image2 " : "image ") << uint32 (face_num); if (ns->image2) sl << uint8 (0); sl << uint32 (d->data.size ()) << data (d->data.data (), d->data.size ()); ns->send_packet (sl); } ns->faces_sent[face_num] |= NS_FACESENT_FACE; } /** * Sends the number of images, checksum of the face file, * and the image_info file information. See the doc/Developers/protocol * if you want further detail. */ void send_image_info (client *ns, char *params) { packet sl; //TODO: second parameter is a checksum, but it makes no sense in this current framework sl.printf ("replyinfo image_info\n%d\n%u\n", MAX_FACES, 0); sl << "0:base:standard:0:32x32:none:The old 32x32 faceset.\n"; ns->send_packet (sl); } /** * Sends requested face information. * \param ns socket to send to * \param params contains first and last index of face * * For each image in [start..stop] sends * - checksum * - name */ void send_image_sums (client *ns, char *params) { int start, stop; char *cp; packet sl; start = atoi (params); for (cp = params; *cp != '\0'; cp++) if (*cp == ' ') break; stop = atoi (cp); if (stop < start || *cp == '\0' || (stop - start) > 1000 || stop >= MAX_FACES) { sl.printf ("replyinfo image_sums %d %d", start, stop); ns->send_packet (sl); sl.reset (); return; } sl.printf ("replyinfo image_sums %d %d ", start, stop); for (int i = start; i <= stop && i < faces.size (); i++) { ns->faces_sent[i] |= NS_FACESENT_FACE; const facedata *d = face_data (i, ns->faceset); if (sl.room () < 2 + 4 + 1 + d->data.size () + 1) break; sl << uint16 (i) << uint32 (0) // checksum << uint8 (ns->faceset); print_facename (sl, *d); sl << uint8 (0); } /* It would make more sense to catch this pre-emptively in the code above. * however, if this really happens, we probably just want to cut down the * size to less than 1000, since that is what we claim the protocol would * support. */ //TODO: taken care of above, should simply abort or make sure the above code is correct if (sl.length () >= MAXSOCKBUF) { LOG (llevError, "send_image_send: buffer overrun, %d > %d\n", sl.length (), MAXSOCKBUF); abort (); } ns->send_packet (sl); }